feat: add inpaint region functionality and related tools

- Enhanced cursor behavior for new tools: semantic select, mask lasso, and mask rectangle.
- Updated mask edit state to include mask asset ID and kind.
- Implemented inpaint region commands for adding, applying, and removing inpaint regions.
- Introduced new operations for lasso and semantic selection tools.
- Created UI components for candidate review and inpaint region management.
- Added tests for inpaint region commands to ensure functionality.
- Updated various components to support new inpaint features and improve user experience.

operations/generation/workflow.ts

@@ -3,7 +3,7 @@ import type { Layer } from "@core/layer";
 import type { GenerationCandidate, GenerationJobKind } from "@editor/state";
 import type { AppStore } from "@editor/store";
 import type { GenerateSettings } from "@editor/tools";
-import { createRefinementMask } from "@operations/masks/rasterActions";
+import { createInpaintRegionMask, createRefinementMask } from "@operations/masks/rasterActions";
 import { createMaskedPixelReplacementSource } from "./candidateActions";
 import { runGenerationJob } from "./generationJob";
 import { loadGenerationResources } from "./loadResources";
@@ -17,6 +17,7 @@ export type GenerationWorkflowDependencies = {
   runGenerateFromCandidate: typeof runGenerateFromCandidate;
   createMaskedPixelReplacementSource: typeof createMaskedPixelReplacementSource;
   createRefinementMask: typeof createRefinementMask;
+  createInpaintRegionMask: typeof createInpaintRegionMask;
   loadGenerationResources: typeof loadGenerationResources;
   createId(): string;
 };
@@ -26,13 +27,14 @@ const defaultDependencies: GenerationWorkflowDependencies = {
   runGenerateFromCandidate,
   createMaskedPixelReplacementSource,
   createRefinementMask,
+  createInpaintRegionMask,
   loadGenerationResources,
   createId: () => crypto.randomUUID(),
 };
 
 export function createGenerationWorkflow(store: AppStore, dependencies: GenerationWorkflowDependencies = defaultDependencies) {
   let activeController: AbortController | undefined;
-  const job = async (kind: GenerationJobKind, label: string, task: (signal: AbortSignal) => Promise<void>) => {
+  const job = async (kind: GenerationJobKind, label: string, task: (signal: AbortSignal, report: (progress: number, detail: string) => void) => Promise<void>) => {
     if (store.getState().editor.generation.jobs.some((candidate) => candidate.status === "running")) return;
     const controller = new AbortController();
     activeController = controller;
@@ -60,26 +62,22 @@ export function createGenerationWorkflow(store: AppStore, dependencies: Generati
       if (!layer || (layer.type !== "image" && layer.type !== "raster")) return;
       const asset = state.document.assets.find((candidate) => candidate.id === layer.assetId);
       if (!asset) return;
-      const source = await dependencies.createRefinementMask(asset.intrinsicSize.w, asset.intrinsicSize.h);
+      const existing = state.document.inpaintRegions.find((region) => region.targetLayerId === layerId && region.enabled);
+      if (existing) {
+        store.dispatch(commandIds.toolEnterInpaintRegionEdit, { targetLayerId: layerId, regionId: existing.id });
+        return;
+      }
+      const source = await dependencies.createInpaintRegionMask(asset.intrinsicSize.w, asset.intrinsicSize.h);
       const maskAssetId = dependencies.createId();
-      const maskLayerId = dependencies.createId();
-      store.dispatch(commandIds.documentAddLayerMask, {
-        layerId,
-        asset: { id: maskAssetId, name: `${layer.name} AI edit mask`, mimeType: "image/png", source, intrinsicSize: { ...asset.intrinsicSize } },
-        maskLayer: {
-          id: maskLayerId,
-          type: "raster",
-          name: `${layer.name} AI edit mask`,
-          visible: true,
-          locked: false,
-          opacity: 1,
-          assetId: maskAssetId,
-          transform: { position: { ...layer.transform.position }, scale: { ...layer.transform.scale }, rotation: layer.transform.rotation },
-        },
+      const regionId = dependencies.createId();
+      store.dispatch(commandIds.documentAddInpaintRegion, {
+        region: { id: regionId, name: `${layer.name} AI edit`, targetLayerId: layer.id, maskAssetId, enabled: true },
+        maskAsset: { id: maskAssetId, name: `${layer.name} AI edit mask`, mimeType: "image/png", source, intrinsicSize: { ...asset.intrinsicSize } },
       });
+      store.dispatch(commandIds.toolEnterInpaintRegionEdit, { targetLayerId: layer.id, regionId });
     },
 
-    generate: () => job("generate", "Generating", async (signal) => {
+    generate: () => job("generate", "Generating", async (signal, report) => {
       const state = store.getState();
       await dependencies.runGenerate({
         document: state.document,
@@ -88,15 +86,34 @@ export function createGenerationWorkflow(store: AppStore, dependencies: Generati
         settings: state.editor.tools.generate,
         dispatch: store.dispatch,
         signal,
+        onProgress: report,
       });
     }),
 
     regenerate: (candidateId: string, settings?: GenerateSettings, label = "Regenerate") =>
-      job("regenerate", label, async (signal) => {
+      job("regenerate", label, async (signal, report) => {
         const candidate = findCandidate(store, candidateId);
         const nextSettings = settings ?? candidate.settings;
         store.dispatch(commandIds.toolSetGenerateSettings, nextSettings);
-        await dependencies.runGenerateFromCandidate({ candidate, settings: nextSettings, dispatch: store.dispatch, signal });
+        await dependencies.runGenerateFromCandidate({ candidate, settings: nextSettings, dispatch: store.dispatch, signal, onProgress: report });
+      }),
+
+    rebuildFromCurrentRegion: (candidateId: string) =>
+      job("regenerate", "Rebuilding from current edit region", async (signal, report) => {
+        const candidate = findCandidate(store, candidateId);
+        if (!candidate.inpaint) throw new Error("Only inpaint candidates can rebuild from an edit region.");
+        store.dispatch(commandIds.selectionSet, { artboardId: candidate.placement.artboardId, layerIds: [candidate.inpaint.targetLayerId] });
+        store.dispatch(commandIds.toolSetGenerateSettings, candidate.settings);
+        const state = store.getState();
+        await dependencies.runGenerate({
+          document: state.document,
+          selection: state.editor.selection,
+          viewport: state.editor.viewport,
+          settings: candidate.settings,
+          dispatch: store.dispatch,
+          signal,
+          onProgress: report,
+        });
       }),
 
     applyCandidateAsLayer: (candidateId: string) => {