@genfeedai/workflow-ui 0.1.2 → 0.1.4

package/dist/lib.mjs

@@ -1,3 +1,563 @@
-export { DEFAULT_IMAGE_MODEL, DEFAULT_LIPSYNC_MODEL, DEFAULT_LLM_MODEL, DEFAULT_VIDEO_MODEL, EASING_PRESETS, IMAGE_MODELS, IMAGE_MODEL_ID_MAP, IMAGE_MODEL_MAP, LIPSYNC_MODELS, LIPSYNC_SYNC_MODES, LLM_MODELS, LLM_MODEL_ID_MAP, LLM_MODEL_MAP, VIDEO_MODELS, VIDEO_MODEL_ID_MAP, VIDEO_MODEL_MAP, applySpeedCurve, evaluateBezier, generateHandlesFromSchema, getEasingDisplayName, getImageModelLabel, getLLMModelLabel, getLipSyncModelLabel, getMediaFromNode, getVideoModelLabel, isSchemaHandle, lipSyncModelSupportsImage } from './chunk-E323WAZG.mjs';
+import { easing, getEasingFunction } from './chunk-6PSJTBNV.mjs';
+export { CubicBezierEditor, DEFAULT_CUSTOM_BEZIER, DEFAULT_IMAGE_MODEL, DEFAULT_LIPSYNC_MODEL, DEFAULT_LLM_MODEL, DEFAULT_VIDEO_MODEL, EASING_BEZIER_MAP, EASING_PRESETS, IMAGE_MODELS, IMAGE_MODEL_ID_MAP, IMAGE_MODEL_MAP, LIPSYNC_MODELS, LIPSYNC_SYNC_MODES, LLM_MODELS, LLM_MODEL_ID_MAP, LLM_MODEL_MAP, PRESET_BEZIERS, VIDEO_MODELS, VIDEO_MODEL_ID_MAP, VIDEO_MODEL_MAP, applySpeedCurve, createAsymmetricEase, createBezierEasing, easing, evaluateBezier, generateHandlesFromSchema, getAllEasingNames, getEasingBezier, getEasingDisplayName, getEasingFunction, getImageModelLabel, getLLMModelLabel, getLipSyncModelLabel, getMediaFromNode, getPresetBezier, getVideoModelLabel, isSchemaHandle, lipSyncModelSupportsImage } from './chunk-6PSJTBNV.mjs';
+export { calculateWorkflowCost, formatCost } from './chunk-JTPADIUO.mjs';
+import './chunk-OY7BRSGG.mjs';
 export { CONNECTION_FIELDS, extractEnumValues, getImageDimensions, getSchemaDefaults, getVideoMetadata, supportsImageInput, validateRequiredSchemaFields } from './chunk-EFXQT23N.mjs';
-import './chunk-ZJWP5KGZ.mjs';
+
+// src/lib/speedCurve.ts
+var INVERSE_TOLERANCE = 1e-6;
+var INVERSE_MAX_ITERATIONS = 32;
+var MONOTONICITY_SAMPLES = 256;
+var MONOTONICITY_TOLERANCE = 1e-6;
+var inverseCache = /* @__PURE__ */ new WeakMap();
+var monotonicityCache = /* @__PURE__ */ new WeakMap();
+function isMonotonicIncreasing(func) {
+  const cached = monotonicityCache.get(func);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let prev = func(0);
+  for (let i = 1; i <= MONOTONICITY_SAMPLES; i++) {
+    const value = func(i / MONOTONICITY_SAMPLES);
+    if (value + MONOTONICITY_TOLERANCE < prev) {
+      monotonicityCache.set(func, false);
+      return false;
+    }
+    prev = value;
+  }
+  monotonicityCache.set(func, true);
+  return true;
+}
+function invertEasingValue(target, func) {
+  if (target <= INVERSE_TOLERANCE) {
+    return 0;
+  }
+  if (target >= 1 - INVERSE_TOLERANCE) {
+    return 1;
+  }
+  let low = 0;
+  let high = 1;
+  let mid = 0.5;
+  for (let i = 0; i < INVERSE_MAX_ITERATIONS; i++) {
+    mid = (low + high) / 2;
+    const value = func(mid);
+    const diff = value - target;
+    if (Math.abs(diff) <= INVERSE_TOLERANCE) {
+      break;
+    }
+    if (diff < 0) {
+      low = mid;
+    } else {
+      high = mid;
+    }
+  }
+  return Math.min(1, Math.max(0, mid));
+}
+function getInverseEasing(func) {
+  if (inverseCache.has(func)) {
+    return inverseCache.get(func);
+  }
+  if (!isMonotonicIncreasing(func)) {
+    inverseCache.set(func, null);
+    return null;
+  }
+  const inverse = (value) => {
+    const clamped = Math.max(0, Math.min(1, value));
+    return invertEasingValue(clamped, func);
+  };
+  inverseCache.set(func, inverse);
+  return inverse;
+}
+function mapTimeWithEasing(normalizedTime, func) {
+  const inverse = getInverseEasing(func);
+  if (!inverse) {
+    return func(normalizedTime);
+  }
+  return inverse(normalizedTime);
+}
+function warpTime(originalTime, inputDuration = 5, outputDuration = 1.5, easingFunction = easing.easeInOutCubic) {
+  const easingFunc = typeof easingFunction === "string" ? getEasingFunction(easingFunction) : easingFunction;
+  const t = originalTime / inputDuration;
+  const clamped = Math.max(0, Math.min(1, t));
+  const eased = mapTimeWithEasing(clamped, easingFunc);
+  return eased * outputDuration;
+}
+function calculateWarpedDuration(originalStart, originalDuration, inputDuration = 5, outputDuration = 1.5, easingFunction = easing.easeInOutCubic) {
+  const warpedStart = warpTime(originalStart, inputDuration, outputDuration, easingFunction);
+  const warpedEnd = warpTime(
+    originalStart + originalDuration,
+    inputDuration,
+    outputDuration,
+    easingFunction
+  );
+  return warpedEnd - warpedStart;
+}
+function validateWarpFunction(easingFunction = easing.easeInOutCubic, inputDuration = 5, outputDuration = 1.5, tolerance = 1e-3) {
+  const errors = [];
+  const startWarp = warpTime(0, inputDuration, outputDuration, easingFunction);
+  if (Math.abs(startWarp - 0) > tolerance) {
+    errors.push(`Start point should be 0, got ${startWarp}`);
+  }
+  const endWarp = warpTime(inputDuration, inputDuration, outputDuration, easingFunction);
+  if (Math.abs(endWarp - outputDuration) > tolerance) {
+    errors.push(`End point should be ${outputDuration}, got ${endWarp}`);
+  }
+  let prevWarp = 0;
+  for (let t = 0; t <= inputDuration; t += inputDuration / 100) {
+    const warp = warpTime(t, inputDuration, outputDuration, easingFunction);
+    if (warp < prevWarp) {
+      errors.push(`Monotonicity violation at t=${t.toFixed(2)}: ${warp} < ${prevWarp}`);
+      break;
+    }
+    prevWarp = warp;
+  }
+  return { valid: errors.length === 0, errors };
+}
+function analyzeWarpCurve(easingFunction = easing.easeInOutCubic, inputDuration = 5, outputDuration = 1.5, samples = 100) {
+  const speedMultipliers = [];
+  const averageSpeed = inputDuration / outputDuration;
+  for (let i = 0; i < samples; i++) {
+    const t1 = i / samples * inputDuration;
+    const t2 = (i + 1) / samples * inputDuration;
+    const warp1 = warpTime(t1, inputDuration, outputDuration, easingFunction);
+    const warp2 = warpTime(t2, inputDuration, outputDuration, easingFunction);
+    const inputSegmentDuration = t2 - t1;
+    const outputSegmentDuration = warp2 - warp1;
+    const absoluteSpeed = inputSegmentDuration / (outputSegmentDuration + 1e-10);
+    const speedMultiplier = absoluteSpeed / averageSpeed;
+    speedMultipliers.push(speedMultiplier);
+  }
+  const minSpeed = Math.min(...speedMultipliers);
+  const maxSpeed = Math.max(...speedMultipliers);
+  const avgSpeed = speedMultipliers.reduce((a, b) => a + b, 0) / speedMultipliers.length;
+  return { speedMultipliers, minSpeed, maxSpeed, avgSpeed };
+}
+
+// src/lib/gridSplitter.ts
+var COMMON_ASPECT_RATIOS = [
+  16 / 9,
+  // 1.778 - Widescreen video
+  4 / 3,
+  // 1.333 - Standard photo/video
+  3 / 2,
+  // 1.5 - DSLR photos
+  1.85,
+  // 1.85:1 - Cinema flat
+  2.39,
+  // 2.39:1 - Cinema scope
+  1,
+  // 1:1 - Square
+  9 / 16,
+  // 0.5625 - Portrait video
+  3 / 4,
+  // 0.75 - Portrait photo
+  2 / 3
+  // 0.667 - Portrait DSLR
+];
+async function detectGrid(imageDataUrl) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.crossOrigin = "anonymous";
+    img.onload = () => {
+      try {
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          reject(new Error("Could not get canvas context"));
+          return;
+        }
+        canvas.width = img.width;
+        canvas.height = img.height;
+        ctx.drawImage(img, 0, 0);
+        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        const result = analyzeGridFromImageData(imageData);
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    img.onerror = () => {
+      reject(new Error("Failed to load image"));
+    };
+    img.src = imageDataUrl;
+  });
+}
+function createGridForDimensions(width, height, rows, cols) {
+  const cellWidth = width / cols;
+  const cellHeight = height / rows;
+  const cells = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      cells.push({
+        x: Math.round(col * cellWidth),
+        y: Math.round(row * cellHeight),
+        width: Math.round(cellWidth),
+        height: Math.round(cellHeight)
+      });
+    }
+  }
+  return { rows, cols, cells, confidence: 1 };
+}
+async function detectGridWithDimensions(imageDataUrl, rows, cols) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.crossOrigin = "anonymous";
+    img.onload = () => {
+      const result = createGridForDimensions(img.width, img.height, rows, cols);
+      resolve(result);
+    };
+    img.onerror = () => {
+      reject(new Error("Failed to load image"));
+    };
+    img.src = imageDataUrl;
+  });
+}
+function aspectRatioScore(aspectRatio) {
+  let bestMatch = Infinity;
+  for (const commonAR of COMMON_ASPECT_RATIOS) {
+    const ratio = aspectRatio > commonAR ? aspectRatio / commonAR : commonAR / aspectRatio;
+    const distance = ratio - 1;
+    bestMatch = Math.min(bestMatch, distance);
+  }
+  return Math.exp(-bestMatch * 3);
+}
+function getGridCandidates(width, height) {
+  const candidates = [];
+  const imageAspectRatio = width / height;
+  for (let rows = 1; rows <= 6; rows++) {
+    for (let cols = 1; cols <= 6; cols++) {
+      if (rows === 1 && cols === 1) continue;
+      const cellWidth = width / cols;
+      const cellHeight = height / rows;
+      const cellAspectRatio = cellWidth / cellHeight;
+      const cellARScore = aspectRatioScore(cellAspectRatio);
+      const gridAspectRatio = cols / rows;
+      const layoutRatio = imageAspectRatio > gridAspectRatio ? imageAspectRatio / gridAspectRatio : gridAspectRatio / imageAspectRatio;
+      const layoutScore = Math.exp(-(layoutRatio - 1) * 2);
+      const cellCount = rows * cols;
+      const cellCountScore = Math.min(cellCount / 6, 1);
+      const gridSymmetry = 1 - Math.abs(rows - cols) / Math.max(rows, cols);
+      const score = cellARScore * 0.45 + layoutScore * 0.25 + cellCountScore * 0.15 + gridSymmetry * 0.15;
+      candidates.push({
+        rows,
+        cols,
+        cellWidth,
+        cellHeight,
+        cellAspectRatio,
+        score
+      });
+    }
+  }
+  return candidates.sort((a, b) => b.score - a.score);
+}
+function analyzeGridFromImageData(imageData) {
+  const { width, height, data } = imageData;
+  const candidates = getGridCandidates(width, height);
+  const verticalEdgeStrength = calculateVerticalEdgeProfile(data, width, height);
+  const horizontalEdgeStrength = calculateHorizontalEdgeProfile(data, width, height);
+  let bestCandidate = candidates[0];
+  let bestCombinedScore = -Infinity;
+  for (const candidate of candidates.slice(0, 8)) {
+    const edgeScore = scoreGridByEdges(
+      candidate.rows,
+      candidate.cols,
+      width,
+      height,
+      verticalEdgeStrength,
+      horizontalEdgeStrength
+    );
+    const combinedScore = candidate.score * 0.7 + edgeScore * 0.3;
+    if (combinedScore > bestCombinedScore) {
+      bestCombinedScore = combinedScore;
+      bestCandidate = candidate;
+    }
+  }
+  const result = createGridForDimensions(width, height, bestCandidate.rows, bestCandidate.cols);
+  result.confidence = bestCombinedScore;
+  return result;
+}
+function calculateVerticalEdgeProfile(data, width, height) {
+  const profile = new Float32Array(width);
+  for (let x = 1; x < width - 1; x++) {
+    let totalGradient = 0;
+    for (let y = 0; y < height; y++) {
+      const idxLeft = (y * width + (x - 1)) * 4;
+      const idxRight = (y * width + (x + 1)) * 4;
+      const gradR = Math.abs(data[idxRight] - data[idxLeft]);
+      const gradG = Math.abs(data[idxRight + 1] - data[idxLeft + 1]);
+      const gradB = Math.abs(data[idxRight + 2] - data[idxLeft + 2]);
+      totalGradient += (gradR + gradG + gradB) / 3;
+    }
+    profile[x] = totalGradient / height;
+  }
+  return profile;
+}
+function calculateHorizontalEdgeProfile(data, width, height) {
+  const profile = new Float32Array(height);
+  for (let y = 1; y < height - 1; y++) {
+    let totalGradient = 0;
+    for (let x = 0; x < width; x++) {
+      const idxUp = ((y - 1) * width + x) * 4;
+      const idxDown = ((y + 1) * width + x) * 4;
+      const gradR = Math.abs(data[idxDown] - data[idxUp]);
+      const gradG = Math.abs(data[idxDown + 1] - data[idxUp + 1]);
+      const gradB = Math.abs(data[idxDown + 2] - data[idxUp + 2]);
+      totalGradient += (gradR + gradG + gradB) / 3;
+    }
+    profile[y] = totalGradient / width;
+  }
+  return profile;
+}
+function scoreGridByEdges(rows, cols, width, height, verticalProfile, horizontalProfile) {
+  let verticalSum = 0;
+  for (let i = 0; i < verticalProfile.length; i++) {
+    verticalSum += verticalProfile[i];
+  }
+  const verticalBaseline = verticalSum / verticalProfile.length;
+  let horizontalSum = 0;
+  for (let i = 0; i < horizontalProfile.length; i++) {
+    horizontalSum += horizontalProfile[i];
+  }
+  const horizontalBaseline = horizontalSum / horizontalProfile.length;
+  let totalRatio = 0;
+  let divisions = 0;
+  const searchWindow = Math.max(3, Math.floor(Math.min(width / cols, height / rows) * 0.03));
+  if (cols > 1) {
+    const cellWidth = width / cols;
+    for (let i = 1; i < cols; i++) {
+      const expectedPos = Math.round(cellWidth * i);
+      let maxStrength = 0;
+      for (let offset = -searchWindow; offset <= searchWindow; offset++) {
+        const pos = expectedPos + offset;
+        if (pos > 0 && pos < width - 1) {
+          maxStrength = Math.max(maxStrength, verticalProfile[pos]);
+        }
+      }
+      const ratio = verticalBaseline > 0 ? maxStrength / verticalBaseline : 1;
+      totalRatio += Math.min(ratio, 3);
+      divisions++;
+    }
+  }
+  if (rows > 1) {
+    const cellHeight = height / rows;
+    for (let i = 1; i < rows; i++) {
+      const expectedPos = Math.round(cellHeight * i);
+      let maxStrength = 0;
+      for (let offset = -searchWindow; offset <= searchWindow; offset++) {
+        const pos = expectedPos + offset;
+        if (pos > 0 && pos < height - 1) {
+          maxStrength = Math.max(maxStrength, horizontalProfile[pos]);
+        }
+      }
+      const ratio = horizontalBaseline > 0 ? maxStrength / horizontalBaseline : 1;
+      totalRatio += Math.min(ratio, 3);
+      divisions++;
+    }
+  }
+  if (divisions === 0) return 0;
+  const avgRatio = totalRatio / divisions;
+  return Math.min((avgRatio - 1) / 2, 1);
+}
+async function splitImage(imageDataUrl, grid) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.crossOrigin = "anonymous";
+    img.onload = () => {
+      try {
+        const results = [];
+        for (const cell of grid.cells) {
+          const canvas = document.createElement("canvas");
+          const ctx = canvas.getContext("2d");
+          if (!ctx) {
+            reject(new Error("Could not get canvas context"));
+            return;
+          }
+          canvas.width = cell.width;
+          canvas.height = cell.height;
+          ctx.drawImage(
+            img,
+            cell.x,
+            cell.y,
+            cell.width,
+            cell.height,
+            0,
+            0,
+            cell.width,
+            cell.height
+          );
+          results.push(canvas.toDataURL("image/png"));
+        }
+        resolve(results);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    img.onerror = () => {
+      reject(new Error("Failed to load image"));
+    };
+    img.src = imageDataUrl;
+  });
+}
+async function detectAndSplitGrid(imageDataUrl) {
+  const grid = await detectGrid(imageDataUrl);
+  const images = await splitImage(imageDataUrl, grid);
+  return { grid, images };
+}
+async function splitWithDimensions(imageDataUrl, rows, cols) {
+  const grid = await detectGridWithDimensions(imageDataUrl, rows, cols);
+  const images = await splitImage(imageDataUrl, grid);
+  return { grid, images };
+}
+
+// src/lib/nodeDimensions.ts
+function getImageDimensions2(base64DataUrl) {
+  return new Promise((resolve) => {
+    if (!base64DataUrl || !base64DataUrl.startsWith("data:image")) {
+      resolve(null);
+      return;
+    }
+    const img = new Image();
+    img.onload = () => {
+      resolve({ width: img.naturalWidth, height: img.naturalHeight });
+    };
+    img.onerror = () => {
+      resolve(null);
+    };
+    img.src = base64DataUrl;
+  });
+}
+function getVideoDimensions(videoUrl) {
+  return new Promise((resolve) => {
+    if (!videoUrl) {
+      resolve(null);
+      return;
+    }
+    const video = document.createElement("video");
+    video.onloadedmetadata = () => {
+      resolve({ width: video.videoWidth, height: video.videoHeight });
+    };
+    video.onerror = () => {
+      resolve(null);
+    };
+    video.src = videoUrl;
+  });
+}
+var MIN_WIDTH = 200;
+var MAX_WIDTH = 500;
+var MIN_HEIGHT = 200;
+var MAX_HEIGHT = 600;
+var NODE_CHROME_HEIGHT = 100;
+function calculateNodeSize(aspectRatio, baseWidth = 300) {
+  if (!aspectRatio || aspectRatio <= 0 || !Number.isFinite(aspectRatio)) {
+    return { width: 300, height: 300 };
+  }
+  let width = Math.max(MIN_WIDTH, Math.min(MAX_WIDTH, baseWidth));
+  let contentHeight = width / aspectRatio;
+  let totalHeight = contentHeight + NODE_CHROME_HEIGHT;
+  if (totalHeight > MAX_HEIGHT) {
+    contentHeight = MAX_HEIGHT - NODE_CHROME_HEIGHT;
+    width = contentHeight * aspectRatio;
+    totalHeight = MAX_HEIGHT;
+  }
+  if (totalHeight < MIN_HEIGHT) {
+    contentHeight = MIN_HEIGHT - NODE_CHROME_HEIGHT;
+    width = contentHeight * aspectRatio;
+    totalHeight = MIN_HEIGHT;
+  }
+  if (width > MAX_WIDTH) {
+    width = MAX_WIDTH;
+    contentHeight = width / aspectRatio;
+    totalHeight = contentHeight + NODE_CHROME_HEIGHT;
+    totalHeight = Math.max(MIN_HEIGHT, Math.min(MAX_HEIGHT, totalHeight));
+  }
+  if (width < MIN_WIDTH) {
+    width = MIN_WIDTH;
+    contentHeight = width / aspectRatio;
+    totalHeight = contentHeight + NODE_CHROME_HEIGHT;
+    totalHeight = Math.max(MIN_HEIGHT, Math.min(MAX_HEIGHT, totalHeight));
+  }
+  return {
+    width: Math.round(width),
+    height: Math.round(totalHeight)
+  };
+}
+function calculateNodeSizePreservingHeight(aspectRatio, currentHeight) {
+  if (!aspectRatio || aspectRatio <= 0 || !Number.isFinite(aspectRatio)) {
+    return { width: 300, height: currentHeight ?? 300 };
+  }
+  if (currentHeight !== void 0 && currentHeight >= MIN_HEIGHT && currentHeight <= MAX_HEIGHT) {
+    const contentHeight = currentHeight - NODE_CHROME_HEIGHT;
+    let width = contentHeight * aspectRatio;
+    width = Math.max(MIN_WIDTH, Math.min(MAX_WIDTH, width));
+    return {
+      width: Math.round(width),
+      height: Math.round(currentHeight)
+    };
+  }
+  return calculateNodeSize(aspectRatio);
+}
+
+// src/lib/deduplicatedFetch.ts
+var inFlightRequests = /* @__PURE__ */ new Map();
+var responseCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5e3;
+var pendingTimeouts = /* @__PURE__ */ new Map();
+function getCacheKey(url, headers) {
+  if (!headers) return url;
+  const headerObj = headers instanceof Headers ? Object.fromEntries(headers.entries()) : Array.isArray(headers) ? Object.fromEntries(headers) : headers;
+  const sortedHeaders = Object.keys(headerObj).sort().map((k) => `${k}:${headerObj[k]}`).join("|");
+  return `${url}|${sortedHeaders}`;
+}
+async function deduplicatedFetch(url, options) {
+  const cacheKey = getCacheKey(url, options?.headers);
+  const cached = responseCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return new Response(cached.bodyText, {
+      status: cached.status,
+      headers: cached.headers
+    });
+  }
+  const existingRequest = inFlightRequests.get(cacheKey);
+  if (existingRequest) {
+    await existingRequest;
+    const cachedData = responseCache.get(cacheKey);
+    if (cachedData) {
+      return new Response(cachedData.bodyText, {
+        status: cachedData.status,
+        headers: cachedData.headers
+      });
+    }
+    return new Response(JSON.stringify({ error: "Cache miss" }), { status: 500 });
+  }
+  const requestPromise = fetch(url, options).then(async (response) => {
+    try {
+      const bodyText = await response.clone().text();
+      responseCache.set(cacheKey, {
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+        bodyText,
+        timestamp: Date.now()
+      });
+    } catch {
+    }
+    return response;
+  }).finally(() => {
+    const timeoutId = setTimeout(() => {
+      inFlightRequests.delete(cacheKey);
+      pendingTimeouts.delete(cacheKey);
+    }, 50);
+    pendingTimeouts.set(cacheKey, timeoutId);
+  });
+  inFlightRequests.set(cacheKey, requestPromise);
+  return requestPromise;
+}
+function clearFetchCache() {
+  responseCache.clear();
+  inFlightRequests.clear();
+  for (const timeoutId of pendingTimeouts.values()) {
+    clearTimeout(timeoutId);
+  }
+  pendingTimeouts.clear();
+}
+
+export { analyzeWarpCurve, calculateNodeSize, calculateNodeSizePreservingHeight, calculateWarpedDuration, clearFetchCache, createGridForDimensions, deduplicatedFetch, detectAndSplitGrid, detectGrid, detectGridWithDimensions, getGridCandidates, getImageDimensions2 as getImageDimensionsFromDataUrl, getVideoDimensions as getVideoDimensionsFromUrl, splitImage, splitWithDimensions, validateWarpFunction, warpTime };

package/dist/nodes.d.mts

@@ -41,6 +41,8 @@ interface BaseNodeProps extends NodeProps {
 declare function BaseNodeComponent({ id, type, data, selected, children, headerActions, title, titleElement, hideStatusIndicator, width, height, disabledInputs, }: BaseNodeProps): react_jsx_runtime.JSX.Element | null;
 declare const BaseNode: react.MemoExoticComponent<typeof BaseNodeComponent>;
 
+declare function NodeDetailModal(): react_jsx_runtime.JSX.Element | null;
+
 declare function WorkflowInputNodeComponent(props: NodeProps): react_jsx_runtime.JSX.Element;
 declare const WorkflowInputNode: react.MemoExoticComponent<typeof WorkflowInputNodeComponent>;
 
@@ -125,4 +127,4 @@ declare const VideoTrimNode: react.MemoExoticComponent<typeof VideoTrimNodeCompo
 
 declare const nodeTypes: NodeTypes;
 
-export { AnimationNode, AnnotationNode, AudioInputNode, BaseNode, DownloadNode, ImageCompareNode, ImageGenNode, ImageGridSplitNode, ImageInputNode, LLMNode, LipSyncNode, MotionControlNode, OutputGalleryNode, OutputNode, PromptConstructorNode, PromptNode, type ReferencableWorkflow, ReframeNode, ResizeNode, SubtitleNode, TextToSpeechNode, TranscribeNode, UpscaleNode, VideoFrameExtractNode, VideoGenNode, VideoInputNode, VideoStitchNode, VideoTrimNode, VoiceChangeNode, WorkflowInputNode, WorkflowOutputNode, type WorkflowRefApi, WorkflowRefNode, nodeTypes, setWorkflowRefApi };
+export { AnimationNode, AnnotationNode, AudioInputNode, BaseNode, DownloadNode, ImageCompareNode, ImageGenNode, ImageGridSplitNode, ImageInputNode, LLMNode, LipSyncNode, MotionControlNode, NodeDetailModal, OutputGalleryNode, OutputNode, PromptConstructorNode, PromptNode, type ReferencableWorkflow, ReframeNode, ResizeNode, SubtitleNode, TextToSpeechNode, TranscribeNode, UpscaleNode, VideoFrameExtractNode, VideoGenNode, VideoInputNode, VideoStitchNode, VideoTrimNode, VoiceChangeNode, WorkflowInputNode, WorkflowOutputNode, type WorkflowRefApi, WorkflowRefNode, nodeTypes, setWorkflowRefApi };

package/dist/nodes.mjs

@@ -1,14 +1,14 @@
-export { AnimationNode, AnnotationNode, AudioInputNode, BaseNode, DownloadNode, ImageCompareNode, ImageGenNode, ImageGridSplitNode, ImageInputNode, LLMNode, LipSyncNode, MotionControlNode, OutputGalleryNode, OutputNode, PromptConstructorNode, PromptNode, ReframeNode, ResizeNode, SubtitleNode, TextToSpeechNode, TranscribeNode, UpscaleNode, VideoFrameExtractNode, VideoGenNode, VideoInputNode, VideoStitchNode, VideoTrimNode, VoiceChangeNode, WorkflowInputNode, WorkflowOutputNode, WorkflowRefNode, nodeTypes, setWorkflowRefApi } from './chunk-E3YBVMYZ.mjs';
+export { AnimationNode, AnnotationNode, AudioInputNode, BaseNode, DownloadNode, ImageCompareNode, ImageGenNode, ImageGridSplitNode, ImageInputNode, LLMNode, LipSyncNode, MotionControlNode, NodeDetailModal, OutputGalleryNode, OutputNode, PromptConstructorNode, PromptNode, ReframeNode, ResizeNode, SubtitleNode, TextToSpeechNode, TranscribeNode, UpscaleNode, VideoFrameExtractNode, VideoGenNode, VideoInputNode, VideoStitchNode, VideoTrimNode, VoiceChangeNode, WorkflowInputNode, WorkflowOutputNode, WorkflowRefNode, nodeTypes, setWorkflowRefApi } from './chunk-PANZDSP6.mjs';
 import './chunk-ZJD5WMR3.mjs';
-import './chunk-E323WAZG.mjs';
-import './chunk-AOTUCJMA.mjs';
+import './chunk-6PSJTBNV.mjs';
+import './chunk-OY7BRSGG.mjs';
+import './chunk-GWBGK3KL.mjs';
 import './chunk-7SKSRSS7.mjs';
 import './chunk-EFXQT23N.mjs';
 import './chunk-CV4M7CNU.mjs';
 import './chunk-LDN7IX4Y.mjs';
-import './chunk-SQK4JDYY.mjs';
-import './chunk-RIGVIEYB.mjs';
+import './chunk-LT3ZJJL6.mjs';
+import './chunk-R727OFBR.mjs';
 import './chunk-MLJJBBTB.mjs';
 import './chunk-FT33LFII.mjs';
 import './chunk-VRN3UWE5.mjs';
-import './chunk-ZJWP5KGZ.mjs';

package/dist/panels.mjs

@@ -1,4 +1,3 @@
-export { DebugPanel, NodePalette, PanelContainer } from './chunk-AUZR6REQ.mjs';
-import './chunk-SQK4JDYY.mjs';
-import './chunk-RIGVIEYB.mjs';
-import './chunk-ZJWP5KGZ.mjs';
+export { DebugPanel, NodePalette, PanelContainer } from './chunk-OQREHJXK.mjs';
+import './chunk-LT3ZJJL6.mjs';
+import './chunk-R727OFBR.mjs';