@pixerate/editor 0.230.0 → 0.231.1

package/dist/image-editor/index.js

@@ -7141,6 +7141,50 @@ var ImageEditorController = class {
     const enc = encodeSurface(surface);
     return enc ? enc.url : null;
   }
+  maskedImageCache = /* @__PURE__ */ new WeakMap();
+  /**
+   * A pixel layer's own pixels with its raster and vector masks applied, cropped to what shows: a
+   * PNG data URL and its document bounds, or `null` for an unknown or non-pixel layer, or when
+   * nothing shows. Opacity, blending, filters and effects are left out, as in `getLayerDataURL`.
+   * Use it for a masked layer, whose stored pixels (a whole copy, for Separate Subject's subject)
+   * are not what it shows.
+   */
+  getMaskedLayerImage(id) {
+    const layer = this.getLayer(id);
+    if (!layer || layer.type !== "pixel") return null;
+    const surface = this.surfaceOf(layer);
+    const cached = this.maskedImageCache.get(layer);
+    if (cached && cached.surface === surface) return cached.image;
+    const b = this.getLayerBounds(id);
+    let image = null;
+    if (b) {
+      const content = { ...layer, visible: true, opacity: 1, blend: "normal" };
+      delete content.clipped;
+      delete content.fillOpacity;
+      delete content.effects;
+      delete content.filters;
+      const data = this.compositor.composite([content], b, this.compositorSources());
+      let x0 = b.width, y0 = b.height, x1 = -1, y1 = -1;
+      for (let y = 0; y < b.height; y++) {
+        for (let x = 0; x < b.width; x++) {
+          if (!data[(y * b.width + x) * 4 + 3]) continue;
+          if (x < x0) x0 = x;
+          if (x > x1) x1 = x;
+          if (y < y0) y0 = y;
+          if (y > y1) y1 = y;
+        }
+      }
+      if (x1 >= 0) {
+        const w = x1 - x0 + 1;
+        const h = y1 - y0 + 1;
+        const out = new Uint8ClampedArray(w * h * 4);
+        for (let y = 0; y < h; y++) out.set(data.subarray(((y0 + y) * b.width + x0) * 4, ((y0 + y) * b.width + x0 + w) * 4), y * w * 4);
+        image = { url: pngDataUrl(w, h, out, 4), bounds: { x: b.x + x0, y: b.y + y0, width: w, height: h } };
+      }
+    }
+    this.maskedImageCache.set(layer, { surface, image });
+    return image;
+  }
   /**
    * Composites the layer stack in document space without a canvas (annotation layers need one
    * and are left out): `rect` (default: the canvas) as RGBA, straight alpha. Crop, rotation and
@@ -20820,7 +20864,8 @@ function extractNormalizedLayerItems(controller, fallbackImageUrl = "") {
   const imgW = state.imageDimensions?.width || 1;
   const imgH = state.imageDimensions?.height || 1;
   return ctrlLayers.map((l) => {
-    const bounds = controller.getLayerBounds(l.id) || {
+    const masked = l.type === "pixel" && (l.mask || l.vectorMask) ? controller.getMaskedLayerImage(l.id) : null;
+    const bounds = masked?.bounds || controller.getLayerBounds(l.id) || {
       x: 0,
       y: 0,
       width: imgW,
@@ -20828,7 +20873,7 @@ function extractNormalizedLayerItems(controller, fallbackImageUrl = "") {
     };
     const sLayer = sLayerMap.get(l.id);
     const assetKey = sLayer?.asset;
-    const layerDataUrl = assetKey && assets[assetKey] || assets[l.id] || (sLayer?.source === "document" ? fallbackImageUrl : "");
+    const layerDataUrl = masked?.url || assetKey && assets[assetKey] || assets[l.id] || (sLayer?.source === "document" ? fallbackImageUrl : "");
     return {
       id: l.id,
       name: l.name || "Untitled Layer",

package/dist/paint-editor/index.cjs

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12;
 
-var _chunkA57ZQDNNcjs = require('../chunk-A57ZQDNN.cjs');
+var _chunk5T3H7CGGcjs = require('../chunk-5T3H7CGG.cjs');
 
 
 
@@ -3213,7 +3213,7 @@ function timeLapseVideo(frameCount, width, height, fps, holdMs, name = "Time-lap
   }
   const video = { version: 1, name, width: w, height: h, fps, background: "#000000", assets, tracks: [{ id: "v1", kind: "video", clips }] };
   const durationMs = frameCount ? clips[clips.length - 1].start + clips[clips.length - 1].duration : 0;
-  return { video, ffmpeg: _chunkA57ZQDNNcjs.toVideoFfmpeg.call(void 0, video, { output: "timelapse.mp4" }), durationMs };
+  return { video, ffmpeg: _chunk5T3H7CGGcjs.toVideoFfmpeg.call(void 0, video, { output: "timelapse.mp4" }), durationMs };
 }
 async function buildTimeLapse(source, target, options = {}) {
   const maxSide = Math.max(32, Math.min(4096, Math.round(_nullishCoalesce(options.maxSide, () => ( 720)))));

package/dist/paint-editor/index.js

@@ -1,6 +1,6 @@
 import {
   toVideoFfmpeg
-} from "../chunk-ONNNNGNS.js";
+} from "../chunk-CSM5T6SE.js";
 import {
   deserializeLayers,
   exportPsd,

package/dist/video-editor/camera-tools.d.cts

@@ -0,0 +1,10 @@
+/**
+ * Agent tools for provider camera moves on video clips (see `VideoClipCamera`): list the moves
+ * by role, set one on a clip (baked into its transform keys) and clear it. They ride on the video
+ * effects tool provider (`createVideoEffectsToolProvider`).
+ */
+import type { EffectToolContext } from '../effects/tools.cjs';
+import type { AgentTool } from '../tools/registry.cjs';
+import type { VideoEditorController } from './controller.cjs';
+/** The video camera move tools (see the module comment). */
+export declare function videoCameraMoveTools(controller: VideoEditorController, ctx: EffectToolContext): AgentTool[];

package/dist/video-editor/camera-tools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Agent tools for provider camera moves on video clips (see `VideoClipCamera`): list the moves
+ * by role, set one on a clip (baked into its transform keys) and clear it. They ride on the video
+ * effects tool provider (`createVideoEffectsToolProvider`).
+ */
+import type { EffectToolContext } from '../effects/tools.js';
+import type { AgentTool } from '../tools/registry.js';
+import type { VideoEditorController } from './controller.js';
+/** The video camera move tools (see the module comment). */
+export declare function videoCameraMoveTools(controller: VideoEditorController, ctx: EffectToolContext): AgentTool[];

package/dist/video-editor/camera.d.cts

@@ -0,0 +1,47 @@
+/**
+ * Provider camera moves on video clips (see `VideoClipCamera` and `@pixerate/editor/effects`).
+ * A clip is the shot: a `transition` move (`in`) moves the camera from `from` to `framing` from
+ * the clip's start, and a `hold` move (`during`) plays across the rest of the clip. The moves are
+ * baked into the clip's x, y, scale and rotation keys with `sampleEffectCameraMove` at the
+ * project's frame rate, keeping a cut's two keys (a jump), so nothing downstream needs the
+ * provider. The camera looks at the clip's picture as its own transform places it.
+ */
+import type { CameraMoveRole, CameraMoveSpec, CameraStage, CameraView, EffectProvider } from '../effects/types.cjs';
+import type { VideoCameraFraming, VideoClip, VideoClipCamera, VideoProject, VideoTransform } from './types.cjs';
+/** The view that shows `framing` of a `stage`-sized frame (see `VideoCameraFraming`). */
+export declare function videoCameraView(framing: VideoCameraFraming | undefined, stage: CameraStage): CameraView;
+/**
+ * The clip transform that shows `view` of a picture placed by `base`: the picture's centre goes
+ * where the camera puts it (turned by the view's roll round the frame's centre), its scale times
+ * the zoom, its rotation plus the roll. Tilt, turn and blur have no place in a clip transform.
+ */
+export declare function videoTransformOfView(view: CameraView, base: VideoClipCamera['base'], stage: CameraStage): Required<VideoClipCamera['base']>;
+/** What baking a clip's camera moves gave: its transform with the keys, and notes on what could not be kept. */
+export interface VideoCameraBake {
+    transform: VideoTransform;
+    /** Ms from the clip's start of each move's cut, when it has one. */
+    cuts: number[];
+    /** When each move plays (clip ms). */
+    windows: {
+        in?: {
+            start: number;
+            end: number;
+        };
+        during?: {
+            start: number;
+            end: number;
+        };
+    };
+    notes: string[];
+}
+/** The clip's transform as plain numbers, for a camera's `base` (refusing keyed fields, which a camera would replace). */
+export declare function videoCameraBase(clip: VideoClip): VideoClipCamera['base'];
+/**
+ * Bakes a clip's camera moves (its `camera`) into transform keys at the project's frame rate:
+ * `in` from the clip's start over its `ms` (default the move's `durationMs`), then `during`
+ * across the rest of the clip. Keys are linear, one per frame, with both keys of a cut kept.
+ * Async: the provider samples the moves (`sampleEffectCameraMove`).
+ */
+export declare function bakeVideoClipCamera(clip: VideoClip, camera: VideoClipCamera, project: Pick<VideoProject, 'width' | 'height' | 'fps'>, provider: EffectProvider): Promise<VideoCameraBake>;
+/** A clip's camera move for a role as its parts, or undefined. */
+export declare function videoClipCameraMove(clip: Pick<VideoClip, 'camera'> | undefined, role: CameraMoveRole): Exclude<CameraMoveSpec, string> | undefined;

package/dist/video-editor/camera.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Provider camera moves on video clips (see `VideoClipCamera` and `@pixerate/editor/effects`).
+ * A clip is the shot: a `transition` move (`in`) moves the camera from `from` to `framing` from
+ * the clip's start, and a `hold` move (`during`) plays across the rest of the clip. The moves are
+ * baked into the clip's x, y, scale and rotation keys with `sampleEffectCameraMove` at the
+ * project's frame rate, keeping a cut's two keys (a jump), so nothing downstream needs the
+ * provider. The camera looks at the clip's picture as its own transform places it.
+ */
+import type { CameraMoveRole, CameraMoveSpec, CameraStage, CameraView, EffectProvider } from '../effects/types.js';
+import type { VideoCameraFraming, VideoClip, VideoClipCamera, VideoProject, VideoTransform } from './types.js';
+/** The view that shows `framing` of a `stage`-sized frame (see `VideoCameraFraming`). */
+export declare function videoCameraView(framing: VideoCameraFraming | undefined, stage: CameraStage): CameraView;
+/**
+ * The clip transform that shows `view` of a picture placed by `base`: the picture's centre goes
+ * where the camera puts it (turned by the view's roll round the frame's centre), its scale times
+ * the zoom, its rotation plus the roll. Tilt, turn and blur have no place in a clip transform.
+ */
+export declare function videoTransformOfView(view: CameraView, base: VideoClipCamera['base'], stage: CameraStage): Required<VideoClipCamera['base']>;
+/** What baking a clip's camera moves gave: its transform with the keys, and notes on what could not be kept. */
+export interface VideoCameraBake {
+    transform: VideoTransform;
+    /** Ms from the clip's start of each move's cut, when it has one. */
+    cuts: number[];
+    /** When each move plays (clip ms). */
+    windows: {
+        in?: {
+            start: number;
+            end: number;
+        };
+        during?: {
+            start: number;
+            end: number;
+        };
+    };
+    notes: string[];
+}
+/** The clip's transform as plain numbers, for a camera's `base` (refusing keyed fields, which a camera would replace). */
+export declare function videoCameraBase(clip: VideoClip): VideoClipCamera['base'];
+/**
+ * Bakes a clip's camera moves (its `camera`) into transform keys at the project's frame rate:
+ * `in` from the clip's start over its `ms` (default the move's `durationMs`), then `during`
+ * across the rest of the clip. Keys are linear, one per frame, with both keys of a cut kept.
+ * Async: the provider samples the moves (`sampleEffectCameraMove`).
+ */
+export declare function bakeVideoClipCamera(clip: VideoClip, camera: VideoClipCamera, project: Pick<VideoProject, 'width' | 'height' | 'fps'>, provider: EffectProvider): Promise<VideoCameraBake>;
+/** A clip's camera move for a role as its parts, or undefined. */
+export declare function videoClipCameraMove(clip: Pick<VideoClip, 'camera'> | undefined, role: CameraMoveRole): Exclude<CameraMoveSpec, string> | undefined;

package/dist/video-editor/check.d.cts

@@ -6,7 +6,7 @@ export declare function videoClipKeyframes(clip: VideoClip): {
     keys: ReturnType<typeof videoKeysOf>;
 }[];
 export type VideoIssueSeverity = 'error' | 'warning' | 'note';
-export declare const VIDEO_ISSUE_CODES: readonly ["missing-asset", "missing-sequence", "sequence-cycle", "wrong-track", "overlap", "source-overrun", "transition-without-cut", "transition-too-long", "transition-handles", "fades-too-long", "animations-too-long", "animation-keyed", "keyframes-outside-clip", "unknown-duration", "unused-asset", "unused-sequence", "marker-past-end", "missing-target-track", "empty"];
+export declare const VIDEO_ISSUE_CODES: readonly ["missing-asset", "missing-sequence", "sequence-cycle", "wrong-track", "overlap", "source-overrun", "transition-without-cut", "transition-too-long", "transition-handles", "fades-too-long", "animations-too-long", "animation-keyed", "keyframes-outside-clip", "camera-stale", "unknown-duration", "unused-asset", "unused-sequence", "marker-past-end", "missing-target-track", "empty"];
 export type VideoIssueCode = (typeof VIDEO_ISSUE_CODES)[number];
 export interface VideoIssue {
     code: VideoIssueCode;

package/dist/video-editor/check.d.ts

@@ -6,7 +6,7 @@ export declare function videoClipKeyframes(clip: VideoClip): {
     keys: ReturnType<typeof videoKeysOf>;
 }[];
 export type VideoIssueSeverity = 'error' | 'warning' | 'note';
-export declare const VIDEO_ISSUE_CODES: readonly ["missing-asset", "missing-sequence", "sequence-cycle", "wrong-track", "overlap", "source-overrun", "transition-without-cut", "transition-too-long", "transition-handles", "fades-too-long", "animations-too-long", "animation-keyed", "keyframes-outside-clip", "unknown-duration", "unused-asset", "unused-sequence", "marker-past-end", "missing-target-track", "empty"];
+export declare const VIDEO_ISSUE_CODES: readonly ["missing-asset", "missing-sequence", "sequence-cycle", "wrong-track", "overlap", "source-overrun", "transition-without-cut", "transition-too-long", "transition-handles", "fades-too-long", "animations-too-long", "animation-keyed", "keyframes-outside-clip", "camera-stale", "unknown-duration", "unused-asset", "unused-sequence", "marker-past-end", "missing-target-track", "empty"];
 export type VideoIssueCode = (typeof VIDEO_ISSUE_CODES)[number];
 export interface VideoIssue {
     code: VideoIssueCode;

package/dist/video-editor/controller.d.cts

@@ -12,9 +12,10 @@ import { VideoPreviewPixels } from './scopes.cjs';
 import type { VideoPreviewScale } from './proxy.cjs';
 import type { VideoFrameCache } from './frame-cache.cjs';
 import { type VideoSvgOptions } from './render.cjs';
-import type { VideoClipEffect, VideoEffectValues, VideoPlacementMode, VideoProject } from './types.cjs';
+import type { VideoCameraFraming, VideoClipCamera, VideoClipEffect, VideoEffectValues, VideoPlacementMode, VideoProject } from './types.cjs';
 import { EffectsSlot } from '../effects/helpers.cjs';
-import type { EffectDescription, EffectProvider, EffectValue } from '../effects/types.cjs';
+import { type VideoCameraBake } from './camera.cjs';
+import type { CameraMoveRole, CameraMoveSpec, EffectDescription, EffectProvider, EffectSummary, EffectValue } from '../effects/types.cjs';
 import { VideoEffectsEngine, type VideoEffectPlace } from './effects.cjs';
 import { type VideoAnimatable, type VideoKey } from './keyframes.cjs';
 import { type VideoEditPlan, type VideoEditPlanInput } from './plan.cjs';
@@ -50,6 +51,19 @@ export interface VideoEditorOptions {
     effects?: EffectProvider | null;
 }
 /** What `applyClipEffect` and the other effect edits return: the edit result plus what they made or changed. */
+/** What setting or clearing a clip's camera move did: its camera now, the keys baked per property, any cuts and when each move plays (clip ms). */
+export type VideoCameraMoveResult = {
+    ok: true;
+    clip: string;
+    camera: VideoClipCamera | null;
+    keys: Record<'x' | 'y' | 'scale' | 'rotation', number>;
+    cuts: number[];
+    windows: VideoCameraBake['windows'];
+    notes: string[];
+} | {
+    ok: false;
+    error: string;
+};
 export type VideoEffectEditResult = (VideoEditResult & {
     ok: true;
     clip: string;
@@ -272,6 +286,27 @@ export declare class VideoEditorController {
     }, options?: {
         merge?: string;
     }): Promise<VideoEffectEditResult>;
+    /** The provider's camera moves for a role (`transition` into a clip, `hold` while it plays), or all of them. Empty without camera support. */
+    cameraMoves(role?: CameraMoveRole): Promise<EffectSummary[]>;
+    private cameraClip;
+    private cameraEdit;
+    /**
+     * Sets the camera move a clip plays into (`transition`: from `from` to `framing` from the
+     * clip's start) or while it holds (`hold`: across the rest of the clip at `framing`), and bakes
+     * the clip's moves into its x, y, scale and rotation keys at the project's frame rate, keeping a
+     * cut's two keys. The move is checked first (role, preset, values; a preset's values and a move
+     * in's length are written out). A clip whose transform is keyed by hand is refused. One undo step.
+     */
+    setClipCameraMove(clip: string, role: CameraMoveRole, spec: CameraMoveSpec, options?: {
+        from?: VideoCameraFraming | null;
+        framing?: VideoCameraFraming | null;
+        merge?: string;
+    }): Promise<VideoCameraMoveResult>;
+    /**
+     * Removes a clip's camera move for a role and bakes what is left (which needs the provider);
+     * with no move left the transform goes back to what it was before the moves. One undo step.
+     */
+    clearClipCameraMove(clip: string, role: CameraMoveRole): Promise<VideoCameraMoveResult>;
     /** Removes an effect from a clip's stack (works without a provider, so placeholders can be cleared). One undo step. */
     removeClipEffect(clip: string, instance: string): VideoEffectEditResult;
     /**

package/dist/video-editor/controller.d.ts

@@ -12,9 +12,10 @@ import { VideoPreviewPixels } from './scopes.js';
 import type { VideoPreviewScale } from './proxy.js';
 import type { VideoFrameCache } from './frame-cache.js';
 import { type VideoSvgOptions } from './render.js';
-import type { VideoClipEffect, VideoEffectValues, VideoPlacementMode, VideoProject } from './types.js';
+import type { VideoCameraFraming, VideoClipCamera, VideoClipEffect, VideoEffectValues, VideoPlacementMode, VideoProject } from './types.js';
 import { EffectsSlot } from '../effects/helpers.js';
-import type { EffectDescription, EffectProvider, EffectValue } from '../effects/types.js';
+import { type VideoCameraBake } from './camera.js';
+import type { CameraMoveRole, CameraMoveSpec, EffectDescription, EffectProvider, EffectSummary, EffectValue } from '../effects/types.js';
 import { VideoEffectsEngine, type VideoEffectPlace } from './effects.js';
 import { type VideoAnimatable, type VideoKey } from './keyframes.js';
 import { type VideoEditPlan, type VideoEditPlanInput } from './plan.js';
@@ -50,6 +51,19 @@ export interface VideoEditorOptions {
     effects?: EffectProvider | null;
 }
 /** What `applyClipEffect` and the other effect edits return: the edit result plus what they made or changed. */
+/** What setting or clearing a clip's camera move did: its camera now, the keys baked per property, any cuts and when each move plays (clip ms). */
+export type VideoCameraMoveResult = {
+    ok: true;
+    clip: string;
+    camera: VideoClipCamera | null;
+    keys: Record<'x' | 'y' | 'scale' | 'rotation', number>;
+    cuts: number[];
+    windows: VideoCameraBake['windows'];
+    notes: string[];
+} | {
+    ok: false;
+    error: string;
+};
 export type VideoEffectEditResult = (VideoEditResult & {
     ok: true;
     clip: string;
@@ -272,6 +286,27 @@ export declare class VideoEditorController {
     }, options?: {
         merge?: string;
     }): Promise<VideoEffectEditResult>;
+    /** The provider's camera moves for a role (`transition` into a clip, `hold` while it plays), or all of them. Empty without camera support. */
+    cameraMoves(role?: CameraMoveRole): Promise<EffectSummary[]>;
+    private cameraClip;
+    private cameraEdit;
+    /**
+     * Sets the camera move a clip plays into (`transition`: from `from` to `framing` from the
+     * clip's start) or while it holds (`hold`: across the rest of the clip at `framing`), and bakes
+     * the clip's moves into its x, y, scale and rotation keys at the project's frame rate, keeping a
+     * cut's two keys. The move is checked first (role, preset, values; a preset's values and a move
+     * in's length are written out). A clip whose transform is keyed by hand is refused. One undo step.
+     */
+    setClipCameraMove(clip: string, role: CameraMoveRole, spec: CameraMoveSpec, options?: {
+        from?: VideoCameraFraming | null;
+        framing?: VideoCameraFraming | null;
+        merge?: string;
+    }): Promise<VideoCameraMoveResult>;
+    /**
+     * Removes a clip's camera move for a role and bakes what is left (which needs the provider);
+     * with no move left the transform goes back to what it was before the moves. One undo step.
+     */
+    clearClipCameraMove(clip: string, role: CameraMoveRole): Promise<VideoCameraMoveResult>;
     /** Removes an effect from a clip's stack (works without a provider, so placeholders can be cleared). One undo step. */
     removeClipEffect(clip: string, instance: string): VideoEffectEditResult;
     /**

package/dist/video-editor/effect-tools.d.cts

@@ -2,7 +2,8 @@
  * Agent tools for provider effects in the video editor: the shared effect tools
  * (`search_effects`, `describe_effect`, `list_applied_effects`, `apply_effect`, `update_effect`,
  * `remove_effect`) on clips, plus `add_video_effect_clip`, `set_video_effect_transition` and
- * `set_video_effect_keyframes`.
+ * `set_video_effect_keyframes`, and the camera move tools (`list_video_camera_moves`,
+ * `set_clip_camera_move`, `clear_clip_camera_move`).
  */
 import { type AppliedEffectInfo } from '../effects/tools.cjs';
 import type { AgentToolProvider } from '../tools/registry.cjs';

package/dist/video-editor/effect-tools.d.ts

@@ -2,7 +2,8 @@
  * Agent tools for provider effects in the video editor: the shared effect tools
  * (`search_effects`, `describe_effect`, `list_applied_effects`, `apply_effect`, `update_effect`,
  * `remove_effect`) on clips, plus `add_video_effect_clip`, `set_video_effect_transition` and
- * `set_video_effect_keyframes`.
+ * `set_video_effect_keyframes`, and the camera move tools (`list_video_camera_moves`,
+ * `set_clip_camera_move`, `clear_clip_camera_move`).
  */
 import { type AppliedEffectInfo } from '../effects/tools.js';
 import type { AgentToolProvider } from '../tools/registry.js';