fix(ui): remove singleton asserts

Changed from useCallback to useMemo and created stable empty Map instance
and function references. This prevents React from thinking the snapshot
has changed when it returns a new Map() on every call.

The key insight is that useSyncExternalStore requires referentially stable
functions AND return values from getSnapshot to prevent infinite loops.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.github/pull_request_template.md

@@ -18,6 +18,5 @@
 
 - [ ] _The PR has a short but descriptive title, suitable for a changelog_
 - [ ] _Tests added / updated (if applicable)_
-- [ ] _❗Changes to a redux slice have a corresponding migration_
 - [ ] _Documentation added / updated (if applicable)_
 - [ ] _Updated `What's New` copy (if doing a release after this PR)_

CANVAS_MULTI_INSTANCE.md

@@ -0,0 +1,602 @@
+# Canvas Multi-Instance Implementation Plan
+
+## Overview
+Transform the InvokeAI canvas from a singleton architecture to support multiple canvas instances within the canvas tab. Each instance will have independent state, tools, and generation capabilities while sharing the same UI framework.
+
+## Architecture Summary
+
+### Current State
+- Single canvas instance with singleton Redux slice (`canvasSlice`)
+- Global `CanvasManager` instance stored in `$canvasManager` atom
+- Direct component coupling to global canvas state
+- Single workspace panel in dockview layout
+
+### Target State
+- Multiple canvas instances as dockview panels within main panel
+- Redux slice supporting multiple canvas states with active instance tracking
+- Canvas manager registry with instance lifecycle management
+- Context-based API abstraction for components
+- Per-instance readiness and generation
+
+## Implementation Phases
+
+## Phase 1: Redux State Architecture Refactoring
+
+To achieve isolated undo/redo histories, the Redux architecture will be split into two main parts: a `canvasInstanceSlice` that manages the state for a single canvas, and a `canvasesSlice` that acts as a router, managing a collection of undoable instances.
+
+### 1.1 Create `canvasInstanceSlice`
+
+**File**: `src/features/controlLayers/store/canvasInstanceSlice.ts` (new)
+
+This new slice will contain all the drawing-related reducers from the original `canvasSlice`. Its reducer will be wrapped with `redux-undo` to create a single, undoable history.
+
+```typescript
+import { createSlice } from '@reduxjs/toolkit';
+import undoable, { type UndoableOptions } from 'redux-undo';
+import { getInitialCanvasState, type CanvasState } from './types';
+
+// All existing drawing reducers (rasterLayerAdded, etc.) go here
+const reducers = { /* ... */ };
+
+const canvasInstanceSlice = createSlice({
+  name: 'canvasInstance',
+  initialState: getInitialCanvasState(),
+  reducers: reducers,
+});
+
+const undoableConfig: UndoableOptions<CanvasState> = { limit: 64 };
+
+// Export the undoable reducer for a single instance
+export const undoableCanvasInstanceReducer = undoable(canvasInstanceSlice.reducer, undoableConfig);
+export const instanceActions = canvasInstanceSlice.actions;
+```
+
+### 1.2 Create `canvasesSlice` as a Router
+
+**File**: `src/features/controlLayers/store/canvasesSlice.ts` (renamed from `canvasSlice.ts`)
+
+This slice manages the dictionary of canvas instances. It uses `extraReducers` to act as a router, forwarding actions from UI components to the correct `undoableCanvasInstanceReducer` based on `canvasId`.
+
+```typescript
+import { createSlice, type PayloadAction, isAnyOf } from '@reduxjs/toolkit';
+import { undoableCanvasInstanceReducer, instanceActions } from './canvasInstanceSlice';
+import { type Undoable } from 'redux-undo';
+import { type CanvasState } from './types';
+
+interface CanvasesState {
+  instances: Record<string, Undoable<CanvasState>>;
+  activeInstanceId: string | null;
+}
+
+const initialCanvasesState: CanvasesState = { instances: {}, activeInstanceId: null };
+
+export const canvasesSlice = createSlice({
+  name: 'canvases',
+  initialState: initialCanvasesState,
+  reducers: {
+    canvasInstanceAdded: (state, action: PayloadAction<{ canvasId: string }>) => {
+      const { canvasId } = action.payload;
+      state.instances[canvasId] = undoableCanvasInstanceReducer(undefined, { type: '@@INIT' });
+    },
+    canvasInstanceRemoved: (state, action: PayloadAction<{ canvasId: string }>) => {
+      delete state.instances[action.payload.canvasId];
+    },
+    activeCanvasChanged: (state, action: PayloadAction<{ canvasId: string | null }>) => {
+      state.activeInstanceId = action.payload.canvasId;
+    },
+  },
+  extraReducers: (builder) => {
+    builder.addMatcher(
+      isAnyOf(...Object.values(instanceActions)),
+      (state, action) => {
+        const canvasId = (action as PayloadAction).payload?.canvasId;
+        if (canvasId && state.instances[canvasId]) {
+          state.instances[canvasId] = undoableCanvasInstanceReducer(state.instances[canvasId], action);
+        }
+      }
+    );
+  },
+});
+```
+
+### 1.3 Update Selectors
+
+**File**: `src/features/controlLayers/store/selectors.ts`
+
+Selectors must be updated to account for the `Undoable` state shape, accessing the `.present` property for the current state.
+
+```typescript
+// Old
+export const selectCanvasSlice = (state: RootState) => state.canvas;
+
+// New
+export const selectCanvasInstance = (state: RootState, canvasId: string) => 
+  state.canvases.instances[canvasId]?.present;
+
+export const selectActiveCanvas = (state: RootState) => 
+  state.canvases.instances[state.canvases.activeInstanceId]?.present;
+```
+
+### 1.4 Migration Strategy
+
+**File**: `src/app/store/migrations/canvasMigration.ts`
+
+The migration script needs to wrap the old canvas state in the new `instances` and `Undoable` structures.
+
+```typescript
+const migrateCanvasV1ToV2 = (state: any) => {
+  if (state.canvas && !state.canvases) {
+    const canvasId = nanoid();
+    const undoableState = {
+      past: [],
+      present: state.canvas, // The old state becomes the 'present'
+      future: [],
+    };
+    return {
+      ...state,
+      canvases: {
+        instances: {
+          [canvasId]: undoableState
+        },
+        activeInstanceId: canvasId
+      }
+    };
+  }
+  return state;
+};
+```
+
+## Phase 2: Canvas Manager Factory Pattern
+
+### 2.0 Configure Listener Middleware
+
+**File**: `src/app/store/store.ts`
+
+To enable efficient, targeted state subscriptions, the listener middleware must be added to the store. This is a one-time setup.
+
+```typescript
+import { configureStore, createListenerMiddleware } from '@reduxjs/toolkit';
+
+// Create and export the middleware instance
+export const listenerMiddleware = createListenerMiddleware();
+
+export const store = configureStore({
+  reducer: rootReducer,
+  middleware: (getDefaultMiddleware) =>
+    // Prepend the listener middleware to the chain
+    getDefaultMiddleware().prepend(listenerMiddleware.middleware),
+});
+```
+
+### 2.1 Replace Singleton with Registry
+
+**File**: `src/features/controlLayers/store/ephemeral.ts`
+
+```typescript
+// Old
+export const $canvasManager = atom<CanvasManager | null>(null);
+
+// New
+export const $canvasManagers = atom<Map<string, CanvasManager>>(new Map());
+```
+
+### 2.2 Update Canvas Manager Factory
+
+**File**: `src/features/controlLayers/konva/CanvasManagerFactory.ts`
+
+The factory will now manage the lifecycle of state listeners, creating and destroying them alongside the canvas manager instances.
+
+```typescript
+import { listenerMiddleware } from 'src/app/store/store';
+import { selectCanvasInstance } from 'src/features/controlLayers/store/selectors';
+
+export class CanvasManagerFactory {
+  private managers = new Map<string, CanvasManager>();
+  private unsubscribers = new Map<string, () => void>();
+
+  createInstance(
+    canvasId: string,
+    container: HTMLDivElement,
+    store: AppStore,
+    socket: SocketClient
+  ): CanvasManager {
+    const manager = new CanvasManager(container, store, socket, canvasId);
+    this.managers.set(canvasId, manager);
+
+    const listener = listenerMiddleware.startListening({
+      predicate: (action, currentState, previousState) => {
+        const oldState = selectCanvasInstance(previousState, canvasId);
+        const newState = selectCanvasInstance(currentState, canvasId);
+        return oldState !== newState;
+      },
+      effect: (action, listenerApi) => {
+        const latestState = selectCanvasInstance(listenerApi.getState(), canvasId);
+        if (latestState) {
+          manager.onStateUpdated(latestState);
+        }
+      },
+    });
+
+    this.unsubscribers.set(canvasId, listener.unsubscribe);
+    return manager;
+  }
+
+  getInstance(canvasId: string): CanvasManager | undefined {
+    return this.managers.get(canvasId);
+  }
+
+  destroyInstance(canvasId: string): void {
+    this.unsubscribers.get(canvasId)?.();
+    this.unsubscribers.delete(canvasId);
+
+    const manager = this.managers.get(canvasId);
+    if (manager) {
+      manager.destroy();
+      this.managers.delete(canvasId);
+    }
+  }
+}
+```
+
+### 2.3 Update Canvas Manager
+
+**File**: `src/features/controlLayers/konva/CanvasManager.ts`
+
+The manager is now simplified. It no longer subscribes to the store directly, but instead has a new method, `onStateUpdated`, which is called by the listener middleware.
+
+```typescript
+// The constructor no longer manages its own subscription.
+constructor(
+  container: HTMLDivElement,
+  store: AppStore,
+  socket: SocketClient,
+  private canvasId: string
+) {
+  // Initial state can be read once.
+  const initialState = selectCanvasInstance(store.getState(), this.canvasId);
+  if (initialState) {
+    this.onStateUpdated(initialState);
+  }
+}
+
+// New method to be called by the listener middleware's effect.
+public onStateUpdated(state: CanvasState): void {
+  // All logic that used to be in the store.subscribe callback goes here.
+}
+```
+
+## Phase 3: Dockview Integration
+
+### 3.1 Update Canvas Tab Layout
+
+**File**: `src/features/ui/layouts/canvas-tab-auto-layout.tsx`
+
+Modify main panel initialization to support multiple workspace panels:
+```typescript
+const initializeCenterPanelLayout = (tab: TabName, api: DockviewApi) => {
+  navigationApi.registerContainer(tab, 'main', api, () => {
+    // ... existing launchpad and viewer setup
+    
+    // Create first canvas instance
+    const firstCanvasId = nanoid();
+    api.addPanel<DockviewPanelParameters>({
+      id: `${WORKSPACE_PANEL_ID}_${firstCanvasId}`,
+      component: WORKSPACE_PANEL_ID,
+      title: 'Canvas 1',
+      tabComponent: DOCKVIEW_TAB_CANVAS_WORKSPACE_ID,
+      params: {
+        tab,
+        canvasId: firstCanvasId,
+        focusRegion: 'canvas',
+        i18nKey: 'ui.panels.canvas',
+      },
+      position: {
+        direction: 'within',
+        referencePanel: launchpad.id,
+      },
+    });
+  });
+};
+```
+
+### 3.2 Add Canvas Management Actions
+
+**File**: `src/features/ui/components/CanvasInstanceManager.tsx`
+
+```typescript
+export const CanvasInstanceManager = () => {
+  const dispatch = useAppDispatch();
+  const canvasCount = useAppSelector(selectCanvasCount);
+  
+  const addCanvas = useCallback(() => {
+    if (canvasCount >= 3) return;
+    
+    const canvasId = nanoid();
+    const canvasName = `Canvas ${canvasCount + 1}`;
+    
+    // Add to Redux
+    dispatch(canvasInstanceAdded({ canvasId, name: canvasName }));
+    
+    // Add to dockview
+    const api = getDockviewApi('canvas', 'main');
+    api?.addPanel({
+      id: `${WORKSPACE_PANEL_ID}_${canvasId}`,
+      component: WORKSPACE_PANEL_ID,
+      title: canvasName,
+      params: { canvasId },
+    });
+  }, [canvasCount, dispatch]);
+  
+  // ... close canvas handler
+};
+```
+
+## Phase 4: Context-Based Canvas API
+
+### 4.1 Canvas Instance Context
+
+**File**: `src/features/controlLayers/contexts/CanvasInstanceContext.tsx`
+
+```typescript
+interface CanvasInstanceContextValue {
+  canvasId: string;
+  canvasName: string;
+  manager: CanvasManager;
+  dispatch: (action: CanvasAction) => void;
+  useSelector: <T>(selector: (state: CanvasState) => T) => T;
+}
+
+export const CanvasInstanceProvider: React.FC<{
+  canvasId: string;
+  children: React.ReactNode;
+}> = ({ canvasId, children }) => {
+  const store = useAppStore();
+  const manager = useCanvasManager(canvasId);
+  
+  const dispatch = useCallback((action: CanvasAction) => {
+    store.dispatch({ ...action, canvasId });
+  }, [store, canvasId]);
+  
+  const useSelector = useCallback(<T,>(selector: (state: CanvasState) => T) => {
+    return useAppSelector((state) => 
+      selector(selectCanvasInstance(state, canvasId))
+    );
+  }, [canvasId]);
+  
+  const value = useMemo(() => ({
+    canvasId,
+    manager,
+    dispatch,
+    useSelector,
+  }), [canvasId, manager, dispatch, useSelector]);
+  
+  return (
+    <CanvasInstanceContext.Provider value={value}>
+      {children}
+    </CanvasInstanceContext.Provider>
+  );
+};
+```
+
+### 4.2 Update CanvasWorkspacePanel
+
+**File**: `src/features/ui/layouts/CanvasWorkspacePanel.tsx`
+
+```typescript
+export const CanvasWorkspacePanel = memo(({ params }: DockviewPanelProps) => {
+  const { canvasId } = params as { canvasId: string };
+  
+  return (
+    <CanvasInstanceProvider canvasId={canvasId}>
+      <StagingAreaContextProvider sessionId={sessionId}>
+        {/* ... existing content but now scoped to canvasId */}
+      </StagingAreaContextProvider>
+    </CanvasInstanceProvider>
+  );
+});
+```
+
+## Phase 5: Generation Pipeline Updates
+
+### 5.1 Update Readiness Checks
+
+**File**: `src/features/queue/store/readiness.ts`
+
+```typescript
+const getReasonsWhyCannotEnqueueCanvasTab = (arg: {
+  activeCanvasId: string | null;
+  canvasManagers: Map<string, CanvasManager>;
+  // ... other args
+}) => {
+  if (!activeCanvasId) {
+    return [{ content: 'No active canvas' }];
+  }
+  
+  const canvas = canvases[activeCanvasId];
+  const manager = canvasManagers.get(activeCanvasId);
+  
+  if (!canvas || !manager) {
+    return [{ content: 'Canvas not initialized' }];
+  }
+  
+  // ... existing readiness checks using specific canvas/manager
+};
+```
+
+### 5.2 Update Enqueue Hook
+
+**File**: `src/features/queue/hooks/useEnqueueCanvas.ts`
+
+```typescript
+export const useEnqueueCanvas = () => {
+  const store = useAppStore();
+  const activeCanvasId = useAppSelector(selectActiveCanvasId);
+  const canvasManager = useCanvasManager(activeCanvasId);
+  
+  const enqueue = useCallback((prepend: boolean) => {
+    if (!canvasManager || !activeCanvasId) {
+      log.error('No active canvas');
+      return;
+    }
+    
+    return enqueueCanvas(store, canvasManager, activeCanvasId, prepend);
+  }, [canvasManager, activeCanvasId, store]);
+  
+  return enqueue;
+};
+```
+
+## Phase 6: Component Migration
+
+### 6.1 Update Canvas Hooks and Action Dispatching
+
+All canvas-related hooks and action dispatching need to use the new context-aware and instance-aware patterns.
+
+**Drawing Actions**: Use the `dispatch` function from the `useCanvasContext` hook, which automatically injects the correct `canvasId`.
+
+```typescript
+// Old
+export const useAddRasterLayer = () => {
+  const dispatch = useAppDispatch();
+  // ...
+  dispatch(rasterLayerAdded(...));
+}
+
+// New
+import { instanceActions } from '../store/canvasInstanceSlice';
+
+export const useAddRasterLayer = () => {
+  const { dispatch, useSelector } = useCanvasContext();
+  // ...
+  dispatch(instanceActions.rasterLayerAdded(...));
+}
+```
+
+**Undo/Redo Actions**: To undo/redo the *active* canvas, global hooks will dispatch the standard `redux-undo` actions, but they must be wrapped in a payload that includes the active `canvasId`. The `canvasesSlice` router will intercept this and apply the action to the correct history.
+
+```typescript
+import { ActionCreators as UndoActionCreators } from 'redux-undo';
+
+const useUndo = () => {
+  const dispatch = useAppDispatch();
+  const activeCanvasId = useAppSelector(selectActiveCanvasId);
+
+  return () => {
+    if (!activeCanvasId) return;
+    dispatch({ ...UndoActionCreators.undo(), payload: { canvasId: activeCanvasId } });
+  }
+}
+```
+
+### 6.2 Component Updates
+
+Update approximately 45 components that use `useCanvasManager` or canvas selectors:
+- Replace `useAppDispatch()` with `useCanvasContext().dispatch`
+- Replace `useAppSelector(selectCanvas...)` with `useCanvasContext().useSelector(...)`
+- Replace `useCanvasManager()` with `useCanvasContext().manager`
+
+## Phase 7: Navigation & Active Canvas Tracking
+
+### 7.1 Track Active Canvas in Dockview
+
+**File**: `src/features/ui/layouts/canvas-tab-auto-layout.tsx`
+
+```typescript
+// Track active workspace panel
+api.onDidActivePanelChange((panel) => {
+  if (panel?.id.startsWith(WORKSPACE_PANEL_ID)) {
+    const canvasId = panel.params?.canvasId;
+    // When a canvas panel is activated, its canvasId is set as the active canvas ID in redux.
+    // When a non-canvas panel is activated, the active canvas ID is set to null.
+    dispatch(setActiveCanvasId(canvasId ?? null));
+  }
+});
+```
+
+### 7.2 Canvas Tab Management UI
+
+Add UI controls for:
+- Add new canvas button (max 3)
+- Close canvas (with confirmation if has changes)
+- Rename canvas
+- Canvas count indicator
+
+## Testing Strategy
+
+### Unit Tests
+- Redux slice with multiple instances
+- Selector parameterization
+- Context provider isolation
+- Canvas manager lifecycle
+
+### Integration Tests
+- Canvas creation/deletion
+- Switching between canvases
+- Generation from correct canvas
+- State isolation between instances
+
+### E2E Tests
+- Full workflow with multiple canvases
+- Memory cleanup on canvas close
+- Persistence and restoration
+
+## Migration Considerations
+
+### Backward Compatibility
+- Migrate existing single canvas to first instance
+- Preserve all canvas state during migration
+- Version state structure for future migrations
+
+### Performance Monitoring
+- Track memory usage with multiple canvases
+- Monitor React re-render patterns
+- Profile Canvas manager instances
+
+### Rollout Strategy
+1. Feature flag for multi-instance UI
+2. Beta testing with power users
+3. Gradual rollout with monitoring
+4. Full release after stability confirmation
+
+## File Structure Changes
+
+```
+src/features/controlLayers/
+├── store/
+│   ├── canvasesSlice.ts (renamed from canvasSlice.ts)
+│   ├── canvasSelectors.ts (parameterized selectors)
+│   └── canvasMigrations.ts (new)
+├── contexts/
+│   ├── CanvasInstanceContext.tsx (new)
+│   └── CanvasManagerProviderGate.tsx (updated)
+├── konva/
+│   ├── CanvasManager.ts (add canvasId support)
+│   └── CanvasManagerFactory.ts (new)
+└── hooks/
+    └── useCanvasContext.ts (new)
+```
+
+## Key Technical Decisions
+
+1. **Use Dockview's native tabs** rather than implementing custom tab UI
+2. **Context-based API abstraction** to hide multi-instance complexity from components
+3. **Active canvas tracking in Redux** for generation pipeline
+4. **Manager registry pattern** for lifecycle management
+5. **Parameterized selectors** rather than duplicating selector code
+6. **Migration-first approach** to preserve existing user work
+
+## Risk Mitigation
+
+- **Memory leaks**: Implement proper cleanup in manager lifecycle
+- **State corruption**: Add validation and error boundaries per canvas
+- **Performance degradation**: Lazy load non-active canvases
+- **User confusion**: Clear active canvas indication in UI
+- **Data loss**: Auto-save and recovery mechanisms
+
+## Success Metrics
+
+- Support 3 simultaneous canvas instances without performance degradation
+- Zero data loss during canvas operations
+- Maintain current generation speed
+- Clean component API with minimal changes
+- Successful migration of existing canvases

invokeai/app/api/routers/session_queue.py

@@ -7,6 +7,7 @@ from pydantic import BaseModel, Field
 from invokeai.app.api.dependencies import ApiDependencies
 from invokeai.app.services.session_processor.session_processor_common import SessionProcessorStatus
 from invokeai.app.services.session_queue.session_queue_common import (
+    QUEUE_ITEM_STATUS,
     Batch,
     BatchStatus,
     CancelAllExceptCurrentResult,
@@ -17,7 +18,6 @@ from invokeai.app.services.session_queue.session_queue_common import (
     DeleteByDestinationResult,
     EnqueueBatchResult,
     FieldIdentifier,
-    ItemIdsResult,
     PruneResult,
     RetryItemsResult,
     SessionQueueCountsByDestination,
@@ -25,7 +25,7 @@ from invokeai.app.services.session_queue.session_queue_common import (
     SessionQueueItemNotFoundError,
     SessionQueueStatus,
 )
-from invokeai.app.services.shared.sqlite.sqlite_common import SQLiteDirection
+from invokeai.app.services.shared.pagination import CursorPaginatedResults
 
 session_queue_router = APIRouter(prefix="/v1/queue", tags=["queue"])
 
@@ -68,6 +68,36 @@ async def enqueue_batch(
         raise HTTPException(status_code=500, detail=f"Unexpected error while enqueuing batch: {e}")
 
 
+@session_queue_router.get(
+    "/{queue_id}/list",
+    operation_id="list_queue_items",
+    responses={
+        200: {"model": CursorPaginatedResults[SessionQueueItem]},
+    },
+)
+async def list_queue_items(
+    queue_id: str = Path(description="The queue id to perform this operation on"),
+    limit: int = Query(default=50, description="The number of items to fetch"),
+    status: Optional[QUEUE_ITEM_STATUS] = Query(default=None, description="The status of items to fetch"),
+    cursor: Optional[int] = Query(default=None, description="The pagination cursor"),
+    priority: int = Query(default=0, description="The pagination cursor priority"),
+    destination: Optional[str] = Query(default=None, description="The destination of queue items to fetch"),
+) -> CursorPaginatedResults[SessionQueueItem]:
+    """Gets cursor-paginated queue items"""
+
+    try:
+        return ApiDependencies.invoker.services.session_queue.list_queue_items(
+            queue_id=queue_id,
+            limit=limit,
+            status=status,
+            cursor=cursor,
+            priority=priority,
+            destination=destination,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error while listing all items: {e}")
+
+
 @session_queue_router.get(
     "/{queue_id}/list_all",
     operation_id="list_all_queue_items",
@@ -89,56 +119,6 @@ async def list_all_queue_items(
         raise HTTPException(status_code=500, detail=f"Unexpected error while listing all queue items: {e}")
 
 
-@session_queue_router.get(
-    "/{queue_id}/item_ids",
-    operation_id="get_queue_item_ids",
-    responses={
-        200: {"model": ItemIdsResult},
-    },
-)
-async def get_queue_item_ids(
-    queue_id: str = Path(description="The queue id to perform this operation on"),
-    order_dir: SQLiteDirection = Query(default=SQLiteDirection.Descending, description="The order of sort"),
-) -> ItemIdsResult:
-    """Gets all queue item ids that match the given parameters"""
-    try:
-        return ApiDependencies.invoker.services.session_queue.get_queue_item_ids(queue_id=queue_id, order_dir=order_dir)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Unexpected error while listing all queue item ids: {e}")
-
-
-@session_queue_router.post(
-    "/{queue_id}/items_by_ids",
-    operation_id="get_queue_items_by_item_ids",
-    responses={200: {"model": list[SessionQueueItem]}},
-)
-async def get_queue_items_by_item_ids(
-    queue_id: str = Path(description="The queue id to perform this operation on"),
-    item_ids: list[int] = Body(
-        embed=True, description="Object containing list of queue item ids to fetch queue items for"
-    ),
-) -> list[SessionQueueItem]:
-    """Gets queue items for the specified queue item ids. Maintains order of item ids."""
-    try:
-        session_queue_service = ApiDependencies.invoker.services.session_queue
-
-        # Fetch queue items preserving the order of requested item ids
-        queue_items: list[SessionQueueItem] = []
-        for item_id in item_ids:
-            try:
-                queue_item = session_queue_service.get_queue_item(item_id=item_id)
-                if queue_item.queue_id != queue_id:  # Auth protection for items from other queues
-                    continue
-                queue_items.append(queue_item)
-            except Exception:
-                # Skip missing queue items - they may have been deleted between item id fetch and queue item fetch
-                continue
-
-        return queue_items
-    except Exception:
-        raise HTTPException(status_code=500, detail="Failed to get queue items")
-
-
 @session_queue_router.put(
     "/{queue_id}/processor/resume",
     operation_id="resume",
@@ -374,10 +354,7 @@ async def get_queue_item(
 ) -> SessionQueueItem:
     """Gets a queue item"""
     try:
-        queue_item = ApiDependencies.invoker.services.session_queue.get_queue_item(item_id=item_id)
-        if queue_item.queue_id != queue_id:
-            raise HTTPException(status_code=404, detail=f"Queue item with id {item_id} not found in queue {queue_id}")
-        return queue_item
+        return ApiDependencies.invoker.services.session_queue.get_queue_item(item_id)
     except SessionQueueItemNotFoundError:
         raise HTTPException(status_code=404, detail=f"Queue item with id {item_id} not found in queue {queue_id}")
     except Exception as e:

invokeai/app/invocations/baseinvocation.py

@@ -36,9 +36,6 @@ from pydantic_core import PydanticUndefined
 from invokeai.app.invocations.fields import (
     FieldKind,
     Input,
-    InputFieldJSONSchemaExtra,
-    UIType,
-    migrate_model_ui_type,
 )
 from invokeai.app.services.config.config_default import get_config
 from invokeai.app.services.shared.invocation_context import InvocationContext
@@ -259,9 +256,7 @@ class BaseInvocation(ABC, BaseModel):
     is_intermediate: bool = Field(
         default=False,
         description="Whether or not this is an intermediate invocation.",
-        json_schema_extra=InputFieldJSONSchemaExtra(
-            input=Input.Direct, field_kind=FieldKind.NodeAttribute, ui_type=UIType._IsIntermediate
-        ).model_dump(exclude_none=True),
+        json_schema_extra={"ui_type": "IsIntermediate", "field_kind": FieldKind.NodeAttribute},
     )
     use_cache: bool = Field(
         default=True,
@@ -450,15 +445,6 @@ with warnings.catch_warnings():
     RESERVED_PYDANTIC_FIELD_NAMES = {m[0] for m in inspect.getmembers(_Model())}
 
 
-def is_enum_member(value: Any, enum_class: type[Enum]) -> bool:
-    """Checks if a value is a member of an enum class."""
-    try:
-        enum_class(value)
-        return True
-    except ValueError:
-        return False
-
-
 def validate_fields(model_fields: dict[str, FieldInfo], model_type: str) -> None:
     """
     Validates the fields of an invocation or invocation output:
@@ -470,99 +456,51 @@ def validate_fields(model_fields: dict[str, FieldInfo], model_type: str) -> None
     """
     for name, field in model_fields.items():
         if name in RESERVED_PYDANTIC_FIELD_NAMES:
-            raise InvalidFieldError(f"{model_type}.{name}: Invalid field name (reserved by pydantic)")
+            raise InvalidFieldError(f'Invalid field name "{name}" on "{model_type}" (reserved by pydantic)')
 
         if not field.annotation:
-            raise InvalidFieldError(f"{model_type}.{name}: Invalid field type (missing annotation)")
+            raise InvalidFieldError(f'Invalid field type "{name}" on "{model_type}" (missing annotation)')
 
         if not isinstance(field.json_schema_extra, dict):
-            raise InvalidFieldError(f"{model_type}.{name}: Invalid field definition (missing json_schema_extra dict)")
+            raise InvalidFieldError(
+                f'Invalid field definition for "{name}" on "{model_type}" (missing json_schema_extra dict)'
+            )
 
         field_kind = field.json_schema_extra.get("field_kind", None)
 
         # must have a field_kind
-        if not is_enum_member(field_kind, FieldKind):
+        if not isinstance(field_kind, FieldKind):
             raise InvalidFieldError(
-                f"{model_type}.{name}: Invalid field definition for (maybe it's not an InputField or OutputField?)"
+                f'Invalid field definition for "{name}" on "{model_type}" (maybe it\'s not an InputField or OutputField?)'
             )
 
-        if field_kind == FieldKind.Input.value and (
+        if field_kind is FieldKind.Input and (
             name in RESERVED_NODE_ATTRIBUTE_FIELD_NAMES or name in RESERVED_INPUT_FIELD_NAMES
         ):
-            raise InvalidFieldError(f"{model_type}.{name}: Invalid field name (reserved input field name)")
+            raise InvalidFieldError(f'Invalid field name "{name}" on "{model_type}" (reserved input field name)')
 
-        if field_kind == FieldKind.Output.value and name in RESERVED_OUTPUT_FIELD_NAMES:
-            raise InvalidFieldError(f"{model_type}.{name}: Invalid field name (reserved output field name)")
+        if field_kind is FieldKind.Output and name in RESERVED_OUTPUT_FIELD_NAMES:
+            raise InvalidFieldError(f'Invalid field name "{name}" on "{model_type}" (reserved output field name)')
 
-        if field_kind == FieldKind.Internal.value and name not in RESERVED_INPUT_FIELD_NAMES:
-            raise InvalidFieldError(f"{model_type}.{name}: Invalid field name (internal field without reserved name)")
+        if (field_kind is FieldKind.Internal) and name not in RESERVED_INPUT_FIELD_NAMES:
+            raise InvalidFieldError(
+                f'Invalid field name "{name}" on "{model_type}" (internal field without reserved name)'
+            )
 
         # node attribute fields *must* be in the reserved list
         if (
-            field_kind == FieldKind.NodeAttribute.value
+            field_kind is FieldKind.NodeAttribute
             and name not in RESERVED_NODE_ATTRIBUTE_FIELD_NAMES
             and name not in RESERVED_OUTPUT_FIELD_NAMES
         ):
             raise InvalidFieldError(
-                f"{model_type}.{name}: Invalid field name (node attribute field without reserved name)"
+                f'Invalid field name "{name}" on "{model_type}" (node attribute field without reserved name)'
             )
 
         ui_type = field.json_schema_extra.get("ui_type", None)
-        ui_model_base = field.json_schema_extra.get("ui_model_base", None)
-        ui_model_type = field.json_schema_extra.get("ui_model_type", None)
-        ui_model_variant = field.json_schema_extra.get("ui_model_variant", None)
-        ui_model_format = field.json_schema_extra.get("ui_model_format", None)
-
-        if ui_type is not None:
-            # There are 3 cases where we may need to take action:
-            #
-            # 1. The ui_type is a migratable, deprecated value. For example, ui_type=UIType.MainModel value is
-            #    deprecated and should be migrated to:
-            #       - ui_model_base=[BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2]
-            #       - ui_model_type=[ModelType.Main]
-            #
-            # 2. ui_type was set in conjunction with any of the new ui_model_[base|type|variant|format] fields, which
-            #    is not allowed (they are mutually exclusive). In this case, we ignore ui_type and log a warning.
-            #
-            # 3. ui_type is a deprecated value that is not migratable. For example, ui_type=UIType.Image is deprecated;
-            #    Image fields are now automatically detected based on the field's type annotation. In this case, we
-            #    ignore ui_type and log a warning.
-            #
-            # The cases must be checked in this order to ensure proper handling.
-
-            # Easier to work with as an enum
-            ui_type = UIType(ui_type)
-
-            # The enum member values are not always the same as their names - we want to log the name so the user can
-            # easily review their code and see where the deprecated enum member is used.
-            human_readable_name = f"UIType.{ui_type.name}"
-
-            # Case 1: migratable deprecated value
-            did_migrate = migrate_model_ui_type(ui_type, field.json_schema_extra)
-
-            if did_migrate:
-                logger.warning(
-                    f'{model_type}.{name}: Migrated deprecated "ui_type" "{human_readable_name}" to new ui_model_[base|type|variant|format] fields'
-                )
-                field.json_schema_extra.pop("ui_type")
-
-            # Case 2: mutually exclusive with new fields
-            elif (
-                ui_model_base is not None
-                or ui_model_type is not None
-                or ui_model_variant is not None
-                or ui_model_format is not None
-            ):
-                logger.warning(
-                    f'{model_type}.{name}: "ui_type" is mutually exclusive with "ui_model_[base|type|format|variant]", ignoring "ui_type"'
-                )
-                field.json_schema_extra.pop("ui_type")
-
-            # Case 3: deprecated value that is not migratable
-            elif ui_type.startswith("DEPRECATED_"):
-                logger.warning(f'{model_type}.{name}: Deprecated "ui_type" "{human_readable_name}", ignoring')
-                field.json_schema_extra.pop("ui_type")
-
+        if isinstance(ui_type, str) and ui_type.startswith("DEPRECATED_"):
+            logger.warning(f'"UIType.{ui_type.split("_")[-1]}" is deprecated, ignoring')
+            field.json_schema_extra.pop("ui_type")
     return None
 
 

invokeai/app/invocations/cogview4_model_loader.py

@@ -5,7 +5,7 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIType
 from invokeai.app.invocations.model import (
     GlmEncoderField,
     ModelIdentifierField,
@@ -14,7 +14,6 @@ from invokeai.app.invocations.model import (
 )
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.model_manager.config import SubModelType
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
 
 
 @invocation_output("cogview4_model_loader_output")
@@ -39,9 +38,8 @@ class CogView4ModelLoaderInvocation(BaseInvocation):
 
     model: ModelIdentifierField = InputField(
         description=FieldDescriptions.cogview4_model,
+        ui_type=UIType.CogView4MainModel,
         input=Input.Direct,
-        ui_model_base=BaseModelType.CogView4,
-        ui_model_type=ModelType.Main,
     )
 
     def invoke(self, context: InvocationContext) -> CogView4ModelLoaderOutput:

invokeai/app/invocations/controlnet.py

@@ -16,6 +16,7 @@ from invokeai.app.invocations.fields import (
     ImageField,
     InputField,
     OutputField,
+    UIType,
 )
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import ImageOutput
@@ -27,7 +28,6 @@ from invokeai.app.util.controlnet_utils import (
     heuristic_resize_fast,
 )
 from invokeai.backend.image_util.util import np_to_pil, pil_to_np
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
 
 
 class ControlField(BaseModel):
@@ -63,17 +63,13 @@ class ControlOutput(BaseInvocationOutput):
     control: ControlField = OutputField(description=FieldDescriptions.control)
 
 
-@invocation(
-    "controlnet", title="ControlNet - SD1.5, SD2, SDXL", tags=["controlnet"], category="controlnet", version="1.1.3"
-)
+@invocation("controlnet", title="ControlNet - SD1.5, SDXL", tags=["controlnet"], category="controlnet", version="1.1.3")
 class ControlNetInvocation(BaseInvocation):
     """Collects ControlNet info to pass to other nodes"""
 
     image: ImageField = InputField(description="The control image")
     control_model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.controlnet_model,
-        ui_model_base=[BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2, BaseModelType.StableDiffusionXL],
-        ui_model_type=ModelType.ControlNet,
+        description=FieldDescriptions.controlnet_model, ui_type=UIType.ControlNetModel
     )
     control_weight: Union[float, List[float]] = InputField(
         default=1.0, ge=-1, le=2, description="The weight given to the ControlNet"

invokeai/app/invocations/fields.py

@@ -1,19 +1,11 @@
 from enum import Enum
 from typing import Any, Callable, Optional, Tuple
 
-from pydantic import BaseModel, ConfigDict, Field, RootModel, TypeAdapter
+from pydantic import BaseModel, ConfigDict, Field, RootModel, TypeAdapter, model_validator
 from pydantic.fields import _Unset
 from pydantic_core import PydanticUndefined
 
 from invokeai.app.util.metaenum import MetaEnum
-from invokeai.backend.image_util.segment_anything.shared import BoundingBox
-from invokeai.backend.model_manager.taxonomy import (
-    BaseModelType,
-    ClipVariantType,
-    ModelFormat,
-    ModelType,
-    ModelVariantType,
-)
 from invokeai.backend.util.logging import InvokeAILogger
 
 logger = InvokeAILogger.get_logger()
@@ -46,15 +38,47 @@ class UIType(str, Enum, metaclass=MetaEnum):
     used, and the type will be ignored. They are included here for backwards compatibility.
     """
 
+    # region Model Field Types
+    MainModel = "MainModelField"
+    CogView4MainModel = "CogView4MainModelField"
+    FluxMainModel = "FluxMainModelField"
+    SD3MainModel = "SD3MainModelField"
+    SDXLMainModel = "SDXLMainModelField"
+    SDXLRefinerModel = "SDXLRefinerModelField"
+    ONNXModel = "ONNXModelField"
+    VAEModel = "VAEModelField"
+    FluxVAEModel = "FluxVAEModelField"
+    LoRAModel = "LoRAModelField"
+    ControlNetModel = "ControlNetModelField"
+    IPAdapterModel = "IPAdapterModelField"
+    T2IAdapterModel = "T2IAdapterModelField"
+    T5EncoderModel = "T5EncoderModelField"
+    CLIPEmbedModel = "CLIPEmbedModelField"
+    CLIPLEmbedModel = "CLIPLEmbedModelField"
+    CLIPGEmbedModel = "CLIPGEmbedModelField"
+    SpandrelImageToImageModel = "SpandrelImageToImageModelField"
+    ControlLoRAModel = "ControlLoRAModelField"
+    SigLipModel = "SigLipModelField"
+    FluxReduxModel = "FluxReduxModelField"
+    LlavaOnevisionModel = "LLaVAModelField"
+    Imagen3Model = "Imagen3ModelField"
+    Imagen4Model = "Imagen4ModelField"
+    ChatGPT4oModel = "ChatGPT4oModelField"
+    Gemini2_5Model = "Gemini2_5ModelField"
+    FluxKontextModel = "FluxKontextModelField"
+    Veo3Model = "Veo3ModelField"
+    RunwayModel = "RunwayModelField"
+    # endregion
+
     # region Misc Field Types
     Scheduler = "SchedulerField"
     Any = "AnyField"
+    Video = "VideoField"
     # endregion
 
     # region Internal Field Types
     _Collection = "CollectionField"
     _CollectionItem = "CollectionItemField"
-    _IsIntermediate = "IsIntermediate"
     # endregion
 
     # region DEPRECATED
@@ -92,44 +116,13 @@ class UIType(str, Enum, metaclass=MetaEnum):
     CollectionItem = "DEPRECATED_CollectionItem"
     Enum = "DEPRECATED_Enum"
     WorkflowField = "DEPRECATED_WorkflowField"
+    IsIntermediate = "DEPRECATED_IsIntermediate"
     BoardField = "DEPRECATED_BoardField"
     MetadataItem = "DEPRECATED_MetadataItem"
     MetadataItemCollection = "DEPRECATED_MetadataItemCollection"
     MetadataItemPolymorphic = "DEPRECATED_MetadataItemPolymorphic"
     MetadataDict = "DEPRECATED_MetadataDict"
 
-    # Deprecated Model Field Types - use ui_model_[base|type|variant|format] instead
-    MainModel = "DEPRECATED_MainModelField"
-    CogView4MainModel = "DEPRECATED_CogView4MainModelField"
-    FluxMainModel = "DEPRECATED_FluxMainModelField"
-    SD3MainModel = "DEPRECATED_SD3MainModelField"
-    SDXLMainModel = "DEPRECATED_SDXLMainModelField"
-    SDXLRefinerModel = "DEPRECATED_SDXLRefinerModelField"
-    ONNXModel = "DEPRECATED_ONNXModelField"
-    VAEModel = "DEPRECATED_VAEModelField"
-    FluxVAEModel = "DEPRECATED_FluxVAEModelField"
-    LoRAModel = "DEPRECATED_LoRAModelField"
-    ControlNetModel = "DEPRECATED_ControlNetModelField"
-    IPAdapterModel = "DEPRECATED_IPAdapterModelField"
-    T2IAdapterModel = "DEPRECATED_T2IAdapterModelField"
-    T5EncoderModel = "DEPRECATED_T5EncoderModelField"
-    CLIPEmbedModel = "DEPRECATED_CLIPEmbedModelField"
-    CLIPLEmbedModel = "DEPRECATED_CLIPLEmbedModelField"
-    CLIPGEmbedModel = "DEPRECATED_CLIPGEmbedModelField"
-    SpandrelImageToImageModel = "DEPRECATED_SpandrelImageToImageModelField"
-    ControlLoRAModel = "DEPRECATED_ControlLoRAModelField"
-    SigLipModel = "DEPRECATED_SigLipModelField"
-    FluxReduxModel = "DEPRECATED_FluxReduxModelField"
-    LlavaOnevisionModel = "DEPRECATED_LLaVAModelField"
-    Imagen3Model = "DEPRECATED_Imagen3ModelField"
-    Imagen4Model = "DEPRECATED_Imagen4ModelField"
-    ChatGPT4oModel = "DEPRECATED_ChatGPT4oModelField"
-    Gemini2_5Model = "DEPRECATED_Gemini2_5ModelField"
-    FluxKontextModel = "DEPRECATED_FluxKontextModelField"
-    Veo3Model = "DEPRECATED_Veo3ModelField"
-    RunwayModel = "DEPRECATED_RunwayModelField"
-    # endregion
-
 
 class UIComponent(str, Enum, metaclass=MetaEnum):
     """
@@ -338,9 +331,14 @@ class ConditioningField(BaseModel):
     )
 
 
-class BoundingBoxField(BoundingBox):
+class BoundingBoxField(BaseModel):
     """A bounding box primitive value."""
 
+    x_min: int = Field(ge=0, description="The minimum x-coordinate of the bounding box (inclusive).")
+    x_max: int = Field(ge=0, description="The maximum x-coordinate of the bounding box (exclusive).")
+    y_min: int = Field(ge=0, description="The minimum y-coordinate of the bounding box (inclusive).")
+    y_max: int = Field(ge=0, description="The maximum y-coordinate of the bounding box (exclusive).")
+
     score: Optional[float] = Field(
         default=None,
         ge=0.0,
@@ -349,6 +347,21 @@ class BoundingBoxField(BoundingBox):
         "when the bounding box was produced by a detector and has an associated confidence score.",
     )
 
+    @model_validator(mode="after")
+    def check_coords(self):
+        if self.x_min > self.x_max:
+            raise ValueError(f"x_min ({self.x_min}) is greater than x_max ({self.x_max}).")
+        if self.y_min > self.y_max:
+            raise ValueError(f"y_min ({self.y_min}) is greater than y_max ({self.y_max}).")
+        return self
+
+    def tuple(self) -> Tuple[int, int, int, int]:
+        """
+        Returns the bounding box as a tuple suitable for use with PIL's `Image.crop()` method.
+        This method returns a tuple of the form (left, upper, right, lower) == (x_min, y_min, x_max, y_max).
+        """
+        return (self.x_min, self.y_min, self.x_max, self.y_max)
+
 
 class MetadataField(RootModel[dict[str, Any]]):
     """
@@ -415,15 +428,10 @@ class InputFieldJSONSchemaExtra(BaseModel):
     ui_component: Optional[UIComponent] = None
     ui_order: Optional[int] = None
     ui_choice_labels: Optional[dict[str, str]] = None
-    ui_model_base: Optional[list[BaseModelType]] = None
-    ui_model_type: Optional[list[ModelType]] = None
-    ui_model_variant: Optional[list[ClipVariantType | ModelVariantType]] = None
-    ui_model_format: Optional[list[ModelFormat]] = None
 
     model_config = ConfigDict(
         validate_assignment=True,
         json_schema_serialization_defaults_required=True,
-        use_enum_values=True,
     )
 
 
@@ -476,121 +484,16 @@ class OutputFieldJSONSchemaExtra(BaseModel):
     """
 
     field_kind: FieldKind
-    ui_hidden: bool = False
-    ui_order: Optional[int] = None
-    ui_type: Optional[UIType] = None
+    ui_hidden: bool
+    ui_type: Optional[UIType]
+    ui_order: Optional[int]
 
     model_config = ConfigDict(
         validate_assignment=True,
         json_schema_serialization_defaults_required=True,
-        use_enum_values=True,
     )
 
 
-def migrate_model_ui_type(ui_type: UIType | str, json_schema_extra: dict[str, Any]) -> bool:
-    """Migrate deprecated model-specifier ui_type values to new-style ui_model_[base|type|variant|format] in json_schema_extra."""
-    if not isinstance(ui_type, UIType):
-        ui_type = UIType(ui_type)
-
-    ui_model_type: list[ModelType] | None = None
-    ui_model_base: list[BaseModelType] | None = None
-    ui_model_format: list[ModelFormat] | None = None
-    ui_model_variant: list[ClipVariantType | ModelVariantType] | None = None
-
-    match ui_type:
-        case UIType.MainModel:
-            ui_model_base = [BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2]
-            ui_model_type = [ModelType.Main]
-        case UIType.CogView4MainModel:
-            ui_model_base = [BaseModelType.CogView4]
-            ui_model_type = [ModelType.Main]
-        case UIType.FluxMainModel:
-            ui_model_base = [BaseModelType.Flux]
-            ui_model_type = [ModelType.Main]
-        case UIType.SD3MainModel:
-            ui_model_base = [BaseModelType.StableDiffusion3]
-            ui_model_type = [ModelType.Main]
-        case UIType.SDXLMainModel:
-            ui_model_base = [BaseModelType.StableDiffusionXL]
-            ui_model_type = [ModelType.Main]
-        case UIType.SDXLRefinerModel:
-            ui_model_base = [BaseModelType.StableDiffusionXLRefiner]
-            ui_model_type = [ModelType.Main]
-        case UIType.VAEModel:
-            ui_model_type = [ModelType.VAE]
-        case UIType.FluxVAEModel:
-            ui_model_base = [BaseModelType.Flux]
-            ui_model_type = [ModelType.VAE]
-        case UIType.LoRAModel:
-            ui_model_type = [ModelType.LoRA]
-        case UIType.ControlNetModel:
-            ui_model_type = [ModelType.ControlNet]
-        case UIType.IPAdapterModel:
-            ui_model_type = [ModelType.IPAdapter]
-        case UIType.T2IAdapterModel:
-            ui_model_type = [ModelType.T2IAdapter]
-        case UIType.T5EncoderModel:
-            ui_model_type = [ModelType.T5Encoder]
-        case UIType.CLIPEmbedModel:
-            ui_model_type = [ModelType.CLIPEmbed]
-        case UIType.CLIPLEmbedModel:
-            ui_model_type = [ModelType.CLIPEmbed]
-            ui_model_variant = [ClipVariantType.L]
-        case UIType.CLIPGEmbedModel:
-            ui_model_type = [ModelType.CLIPEmbed]
-            ui_model_variant = [ClipVariantType.G]
-        case UIType.SpandrelImageToImageModel:
-            ui_model_type = [ModelType.SpandrelImageToImage]
-        case UIType.ControlLoRAModel:
-            ui_model_type = [ModelType.ControlLoRa]
-        case UIType.SigLipModel:
-            ui_model_type = [ModelType.SigLIP]
-        case UIType.FluxReduxModel:
-            ui_model_type = [ModelType.FluxRedux]
-        case UIType.LlavaOnevisionModel:
-            ui_model_type = [ModelType.LlavaOnevision]
-        case UIType.Imagen3Model:
-            ui_model_base = [BaseModelType.Imagen3]
-            ui_model_type = [ModelType.Main]
-        case UIType.Imagen4Model:
-            ui_model_base = [BaseModelType.Imagen4]
-            ui_model_type = [ModelType.Main]
-        case UIType.ChatGPT4oModel:
-            ui_model_base = [BaseModelType.ChatGPT4o]
-            ui_model_type = [ModelType.Main]
-        case UIType.Gemini2_5Model:
-            ui_model_base = [BaseModelType.Gemini2_5]
-            ui_model_type = [ModelType.Main]
-        case UIType.FluxKontextModel:
-            ui_model_base = [BaseModelType.FluxKontext]
-            ui_model_type = [ModelType.Main]
-        case UIType.Veo3Model:
-            ui_model_base = [BaseModelType.Veo3]
-            ui_model_type = [ModelType.Video]
-        case UIType.RunwayModel:
-            ui_model_base = [BaseModelType.Runway]
-            ui_model_type = [ModelType.Video]
-        case _:
-            pass
-
-    did_migrate = False
-
-    if ui_model_type is not None:
-        json_schema_extra["ui_model_type"] = [m.value for m in ui_model_type]
-        did_migrate = True
-    if ui_model_base is not None:
-        json_schema_extra["ui_model_base"] = [m.value for m in ui_model_base]
-        did_migrate = True
-    if ui_model_format is not None:
-        json_schema_extra["ui_model_format"] = [m.value for m in ui_model_format]
-        did_migrate = True
-    if ui_model_variant is not None:
-        json_schema_extra["ui_model_variant"] = [m.value for m in ui_model_variant]
-        did_migrate = True
-
-    return did_migrate
-
-
 def InputField(
     # copied from pydantic's Field
     # TODO: Can we support default_factory?
@@ -617,63 +520,35 @@ def InputField(
     ui_hidden: Optional[bool] = None,
     ui_order: Optional[int] = None,
     ui_choice_labels: Optional[dict[str, str]] = None,
-    ui_model_base: Optional[BaseModelType | list[BaseModelType]] = None,
-    ui_model_type: Optional[ModelType | list[ModelType]] = None,
-    ui_model_variant: Optional[ClipVariantType | ModelVariantType | list[ClipVariantType | ModelVariantType]] = None,
-    ui_model_format: Optional[ModelFormat | list[ModelFormat]] = None,
 ) -> Any:
     """
     Creates an input field for an invocation.
 
-    This is a wrapper for Pydantic's [Field](https://docs.pydantic.dev/latest/api/fields/#pydantic.fields.Field)
+    This is a wrapper for Pydantic's [Field](https://docs.pydantic.dev/latest/api/fields/#pydantic.fields.Field) \
     that adds a few extra parameters to support graph execution and the node editor UI.
 
-    If the field is a `ModelIdentifierField`, use the `ui_model_[base|type|variant|format]` args to filter the model list
-    in the Workflow Editor. Otherwise, use `ui_type` to provide extra type hints for the UI.
+    :param Input input: [Input.Any] The kind of input this field requires. \
+      `Input.Direct` means a value must be provided on instantiation. \
+      `Input.Connection` means the value must be provided by a connection. \
+      `Input.Any` means either will do.
 
-    Don't use both `ui_type` and `ui_model_[base|type|variant|format]` - if both are provided, a warning will be
-    logged and `ui_type` will be ignored.
+    :param UIType ui_type: [None] Optionally provides an extra type hint for the UI. \
+      In some situations, the field's type is not enough to infer the correct UI type. \
+      For example, model selection fields should render a dropdown UI component to select a model. \
+      Internally, there is no difference between SD-1, SD-2 and SDXL model fields, they all use \
+      `MainModelField`. So to ensure the base-model-specific UI is rendered, you can use \
+      `UIType.SDXLMainModelField` to indicate that the field is an SDXL main model field.
 
-    Args:
-        input: The kind of input this field requires.
-        - `Input.Direct` means a value must be provided on instantiation.
-        - `Input.Connection` means the value must be provided by a connection.
-        - `Input.Any` means either will do.
+    :param UIComponent ui_component: [None] Optionally specifies a specific component to use in the UI. \
+      The UI will always render a suitable component, but sometimes you want something different than the default. \
+      For example, a `string` field will default to a single-line input, but you may want a multi-line textarea instead. \
+      For this case, you could provide `UIComponent.Textarea`.
 
-        ui_type: Optionally provides an extra type hint for the UI. In some situations, the field's type is not enough
-        to infer the correct UI type. For example, Scheduler fields are enums, but we want to render a special scheduler
-        dropdown in the UI. Use `UIType.Scheduler` to indicate this.
+    :param bool ui_hidden: [False] Specifies whether or not this field should be hidden in the UI.
 
-        ui_component: Optionally specifies a specific component to use in the UI. The UI will always render a suitable
-        component, but sometimes you want something different than the default. For example, a `string` field will
-        default to a single-line input, but you may want a multi-line textarea instead. In this case, you could use
-        `UIComponent.Textarea`.
+    :param int ui_order: [None] Specifies the order in which this field should be rendered in the UI.
 
-        ui_hidden: Specifies whether or not this field should be hidden in the UI.
-
-        ui_order: Specifies the order in which this field should be rendered in the UI. If omitted, the field will be
-        rendered after all fields with an explicit order, in the order they are defined in the Invocation class.
-
-        ui_model_base: Specifies the base model architectures to filter the model list by in the Workflow Editor. For
-        example, `ui_model_base=BaseModelType.StableDiffusionXL` will show only SDXL architecture models. This arg is
-        only valid if this Input field is annotated as a `ModelIdentifierField`.
-
-        ui_model_type: Specifies the model type(s) to filter the model list by in the Workflow Editor. For example,
-        `ui_model_type=ModelType.VAE` will show only VAE models. This arg is only valid if this Input field is
-        annotated as a `ModelIdentifierField`.
-
-        ui_model_variant: Specifies the model variant(s) to filter the model list by in the Workflow Editor. For example,
-        `ui_model_variant=ModelVariantType.Inpainting` will show only inpainting models. This arg is only valid if this
-        Input field is annotated as a `ModelIdentifierField`.
-
-        ui_model_format: Specifies the model format(s) to filter the model list by in the Workflow Editor. For example,
-        `ui_model_format=ModelFormat.Diffusers` will show only models in the diffusers format. This arg is only valid
-        if this Input field is annotated as a `ModelIdentifierField`.
-
-        ui_choice_labels: Specifies the labels to use for the choices in an enum field. If omitted, the enum values
-        will be used. This arg is only valid if the field is annotated with as a `Literal`. For example,
-        `Literal["choice1", "choice2", "choice3"]` with `ui_choice_labels={"choice1": "Choice 1", "choice2": "Choice 2",
-        "choice3": "Choice 3"}` will render a dropdown with the labels "Choice 1", "Choice 2" and "Choice 3".
+    :param dict[str, str] ui_choice_labels: [None] Specifies the labels to use for the choices in an enum field.
     """
 
     json_schema_extra_ = InputFieldJSONSchemaExtra(
@@ -681,6 +556,8 @@ def InputField(
         field_kind=FieldKind.Input,
     )
 
+    if ui_type is not None:
+        json_schema_extra_.ui_type = ui_type
     if ui_component is not None:
         json_schema_extra_.ui_component = ui_component
     if ui_hidden is not None:
@@ -689,28 +566,6 @@ def InputField(
         json_schema_extra_.ui_order = ui_order
     if ui_choice_labels is not None:
         json_schema_extra_.ui_choice_labels = ui_choice_labels
-    if ui_model_base is not None:
-        if isinstance(ui_model_base, list):
-            json_schema_extra_.ui_model_base = ui_model_base
-        else:
-            json_schema_extra_.ui_model_base = [ui_model_base]
-    if ui_model_type is not None:
-        if isinstance(ui_model_type, list):
-            json_schema_extra_.ui_model_type = ui_model_type
-        else:
-            json_schema_extra_.ui_model_type = [ui_model_type]
-    if ui_model_variant is not None:
-        if isinstance(ui_model_variant, list):
-            json_schema_extra_.ui_model_variant = ui_model_variant
-        else:
-            json_schema_extra_.ui_model_variant = [ui_model_variant]
-    if ui_model_format is not None:
-        if isinstance(ui_model_format, list):
-            json_schema_extra_.ui_model_format = ui_model_format
-        else:
-            json_schema_extra_.ui_model_format = [ui_model_format]
-    if ui_type is not None:
-        json_schema_extra_.ui_type = ui_type
 
     """
     There is a conflict between the typing of invocation definitions and the typing of an invocation's
@@ -812,20 +667,20 @@ def OutputField(
     """
     Creates an output field for an invocation output.
 
-    This is a wrapper for Pydantic's [Field](https://docs.pydantic.dev/1.10/usage/schema/#field-customization)
+    This is a wrapper for Pydantic's [Field](https://docs.pydantic.dev/1.10/usage/schema/#field-customization) \
     that adds a few extra parameters to support graph execution and the node editor UI.
 
-    Args:
-        ui_type: Optionally provides an extra type hint for the UI. In some situations, the field's type is not enough
-        to infer the correct UI type. For example, Scheduler fields are enums, but we want to render a special scheduler
-        dropdown in the UI. Use `UIType.Scheduler` to indicate this.
+    :param UIType ui_type: [None] Optionally provides an extra type hint for the UI. \
+      In some situations, the field's type is not enough to infer the correct UI type. \
+      For example, model selection fields should render a dropdown UI component to select a model. \
+      Internally, there is no difference between SD-1, SD-2 and SDXL model fields, they all use \
+      `MainModelField`. So to ensure the base-model-specific UI is rendered, you can use \
+      `UIType.SDXLMainModelField` to indicate that the field is an SDXL main model field.
 
-        ui_hidden: Specifies whether or not this field should be hidden in the UI.
+    :param bool ui_hidden: [False] Specifies whether or not this field should be hidden in the UI. \
 
-        ui_order: Specifies the order in which this field should be rendered in the UI. If omitted, the field will be
-        rendered after all fields with an explicit order, in the order they are defined in the Invocation class.
+    :param int ui_order: [None] Specifies the order in which this field should be rendered in the UI. \
     """
-
     return Field(
         default=default,
         title=title,
@@ -843,9 +698,9 @@ def OutputField(
         min_length=min_length,
         max_length=max_length,
         json_schema_extra=OutputFieldJSONSchemaExtra(
+            ui_type=ui_type,
             ui_hidden=ui_hidden,
             ui_order=ui_order,
-            ui_type=ui_type,
             field_kind=FieldKind.Output,
         ).model_dump(exclude_none=True),
     )

invokeai/app/invocations/flux_control_lora_loader.py

@@ -4,10 +4,9 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, OutputField, UIType
 from invokeai.app.invocations.model import ControlLoRAField, ModelIdentifierField
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
 
 
 @invocation_output("flux_control_lora_loader_output")
@@ -30,10 +29,7 @@ class FluxControlLoRALoaderInvocation(BaseInvocation):
     """LoRA model and Image to use with FLUX transformer generation."""
 
     lora: ModelIdentifierField = InputField(
-        description=FieldDescriptions.control_lora_model,
-        title="Control LoRA",
-        ui_model_base=BaseModelType.Flux,
-        ui_model_type=ModelType.ControlLoRa,
+        description=FieldDescriptions.control_lora_model, title="Control LoRA", ui_type=UIType.ControlLoRAModel
     )
     image: ImageField = InputField(description="The image to encode.")
     weight: float = InputField(description="The weight of the LoRA.", default=1.0)

invokeai/app/invocations/flux_controlnet.py

@@ -6,12 +6,11 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, OutputField, UIType
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.controlnet_utils import CONTROLNET_RESIZE_VALUES
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
 
 
 class FluxControlNetField(BaseModel):
@@ -58,9 +57,7 @@ class FluxControlNetInvocation(BaseInvocation):
 
     image: ImageField = InputField(description="The control image")
     control_model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.controlnet_model,
-        ui_model_base=BaseModelType.Flux,
-        ui_model_type=ModelType.ControlNet,
+        description=FieldDescriptions.controlnet_model, ui_type=UIType.ControlNetModel
     )
     control_weight: float | list[float] = InputField(
         default=1.0, ge=-1, le=2, description="The weight given to the ControlNet"

invokeai/app/invocations/flux_ip_adapter.py

@@ -5,7 +5,7 @@ from pydantic import field_validator, model_validator
 from typing_extensions import Self
 
 from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
-from invokeai.app.invocations.fields import InputField
+from invokeai.app.invocations.fields import InputField, UIType
 from invokeai.app.invocations.ip_adapter import (
     CLIP_VISION_MODEL_MAP,
     IPAdapterField,
@@ -20,7 +20,6 @@ from invokeai.backend.model_manager.config import (
     IPAdapterCheckpointConfig,
     IPAdapterInvokeAIConfig,
 )
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
 
 
 @invocation(
@@ -37,10 +36,7 @@ class FluxIPAdapterInvocation(BaseInvocation):
 
     image: ImageField = InputField(description="The IP-Adapter image prompt(s).")
     ip_adapter_model: ModelIdentifierField = InputField(
-        description="The IP-Adapter model.",
-        title="IP-Adapter Model",
-        ui_model_base=BaseModelType.Flux,
-        ui_model_type=ModelType.IPAdapter,
+        description="The IP-Adapter model.", title="IP-Adapter Model", ui_type=UIType.IPAdapterModel
     )
     # Currently, the only known ViT model used by FLUX IP-Adapters is ViT-L.
     clip_vision_model: Literal["ViT-L"] = InputField(description="CLIP Vision model to use.", default="ViT-L")

invokeai/app/invocations/flux_lora_loader.py

@@ -6,10 +6,10 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIType
 from invokeai.app.invocations.model import CLIPField, LoRAField, ModelIdentifierField, T5EncoderField, TransformerField
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
+from invokeai.backend.model_manager.taxonomy import BaseModelType
 
 
 @invocation_output("flux_lora_loader_output")
@@ -36,10 +36,7 @@ class FluxLoRALoaderInvocation(BaseInvocation):
     """Apply a LoRA model to a FLUX transformer and/or text encoder."""
 
     lora: ModelIdentifierField = InputField(
-        description=FieldDescriptions.lora_model,
-        title="LoRA",
-        ui_model_base=BaseModelType.Flux,
-        ui_model_type=ModelType.LoRA,
+        description=FieldDescriptions.lora_model, title="LoRA", ui_type=UIType.LoRAModel
     )
     weight: float = InputField(default=0.75, description=FieldDescriptions.lora_weight)
     transformer: TransformerField | None = InputField(

invokeai/app/invocations/flux_model_loader.py

@@ -6,7 +6,7 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIType
 from invokeai.app.invocations.model import CLIPField, ModelIdentifierField, T5EncoderField, TransformerField, VAEField
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.t5_model_identifier import (
@@ -17,7 +17,7 @@ from invokeai.backend.flux.util import max_seq_lengths
 from invokeai.backend.model_manager.config import (
     CheckpointConfigBase,
 )
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType, SubModelType
+from invokeai.backend.model_manager.taxonomy import SubModelType
 
 
 @invocation_output("flux_model_loader_output")
@@ -46,30 +46,23 @@ class FluxModelLoaderInvocation(BaseInvocation):
 
     model: ModelIdentifierField = InputField(
         description=FieldDescriptions.flux_model,
+        ui_type=UIType.FluxMainModel,
         input=Input.Direct,
-        ui_model_base=BaseModelType.Flux,
-        ui_model_type=ModelType.Main,
     )
 
     t5_encoder_model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.t5_encoder,
-        input=Input.Direct,
-        title="T5 Encoder",
-        ui_model_type=ModelType.T5Encoder,
+        description=FieldDescriptions.t5_encoder, ui_type=UIType.T5EncoderModel, input=Input.Direct, title="T5 Encoder"
     )
 
     clip_embed_model: ModelIdentifierField = InputField(
         description=FieldDescriptions.clip_embed_model,
+        ui_type=UIType.CLIPEmbedModel,
         input=Input.Direct,
         title="CLIP Embed",
-        ui_model_type=ModelType.CLIPEmbed,
     )
 
     vae_model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.vae_model,
-        title="VAE",
-        ui_model_base=BaseModelType.Flux,
-        ui_model_type=ModelType.VAE,
+        description=FieldDescriptions.vae_model, ui_type=UIType.FluxVAEModel, title="VAE"
     )
 
     def invoke(self, context: InvocationContext) -> FluxModelLoaderOutput:

invokeai/app/invocations/flux_redux.py

@@ -18,6 +18,7 @@ from invokeai.app.invocations.fields import (
     InputField,
     OutputField,
     TensorField,
+    UIType,
 )
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import ImageField
@@ -63,8 +64,7 @@ class FluxReduxInvocation(BaseInvocation):
     redux_model: ModelIdentifierField = InputField(
         description="The FLUX Redux model to use.",
         title="FLUX Redux Model",
-        ui_model_base=BaseModelType.Flux,
-        ui_model_type=ModelType.FluxRedux,
+        ui_type=UIType.FluxReduxModel,
     )
     downsampling_factor: int = InputField(
         ge=1,

invokeai/app/invocations/ip_adapter.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, Field, field_validator, model_validator
 from typing_extensions import Self
 
 from invokeai.app.invocations.baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
-from invokeai.app.invocations.fields import FieldDescriptions, InputField, OutputField, TensorField
+from invokeai.app.invocations.fields import FieldDescriptions, InputField, OutputField, TensorField, UIType
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import ImageField
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
@@ -85,8 +85,7 @@ class IPAdapterInvocation(BaseInvocation):
         description="The IP-Adapter model.",
         title="IP-Adapter Model",
         ui_order=-1,
-        ui_model_base=[BaseModelType.StableDiffusion1, BaseModelType.StableDiffusionXL],
-        ui_model_type=ModelType.IPAdapter,
+        ui_type=UIType.IPAdapterModel,
     )
     clip_vision_model: Literal["ViT-H", "ViT-G", "ViT-L"] = InputField(
         description="CLIP Vision model to use. Overrides model settings. Mandatory for checkpoint models.",

invokeai/app/invocations/llava_onevision_vllm.py

@@ -6,12 +6,11 @@ from pydantic import field_validator
 from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration, LlavaOnevisionProcessor
 
 from invokeai.app.invocations.baseinvocation import BaseInvocation, Classification, invocation
-from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, UIComponent
+from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, UIComponent, UIType
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import StringOutput
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.llava_onevision_pipeline import LlavaOnevisionPipeline
-from invokeai.backend.model_manager.taxonomy import ModelType
 from invokeai.backend.util.devices import TorchDevice
 
 
@@ -35,7 +34,7 @@ class LlavaOnevisionVllmInvocation(BaseInvocation):
     vllm_model: ModelIdentifierField = InputField(
         title="LLaVA Model Type",
         description=FieldDescriptions.vllm_model,
-        ui_model_type=ModelType.LlavaOnevision,
+        ui_type=UIType.LlavaOnevisionModel,
     )
 
     @field_validator("images", mode="before")

invokeai/app/invocations/metadata_linked.py

@@ -53,7 +53,7 @@ from invokeai.app.invocations.primitives import (
 from invokeai.app.invocations.scheduler import SchedulerOutput
 from invokeai.app.invocations.t2i_adapter import T2IAdapterField, T2IAdapterInvocation
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType, SubModelType
+from invokeai.backend.model_manager.taxonomy import ModelType, SubModelType
 from invokeai.backend.stable_diffusion.schedulers.schedulers import SCHEDULER_NAME_VALUES
 from invokeai.version import __version__
 
@@ -473,6 +473,7 @@ class MetadataToModelOutput(BaseInvocationOutput):
     model: ModelIdentifierField = OutputField(
         description=FieldDescriptions.main_model,
         title="Model",
+        ui_type=UIType.MainModel,
     )
     name: str = OutputField(description="Model Name", title="Name")
     unet: UNetField = OutputField(description=FieldDescriptions.unet, title="UNet")
@@ -487,6 +488,7 @@ class MetadataToSDXLModelOutput(BaseInvocationOutput):
     model: ModelIdentifierField = OutputField(
         description=FieldDescriptions.main_model,
         title="Model",
+        ui_type=UIType.SDXLMainModel,
     )
     name: str = OutputField(description="Model Name", title="Name")
     unet: UNetField = OutputField(description=FieldDescriptions.unet, title="UNet")
@@ -517,7 +519,8 @@ class MetadataToModelInvocation(BaseInvocation, WithMetadata):
         input=Input.Direct,
     )
     default_value: ModelIdentifierField = InputField(
-        description="The default model to use if not found in the metadata", ui_model_type=ModelType.Main
+        description="The default model to use if not found in the metadata",
+        ui_type=UIType.MainModel,
     )
 
     _validate_custom_label = model_validator(mode="after")(validate_custom_label)
@@ -572,8 +575,7 @@ class MetadataToSDXLModelInvocation(BaseInvocation, WithMetadata):
     )
     default_value: ModelIdentifierField = InputField(
         description="The default SDXL Model to use if not found in the metadata",
-        ui_model_type=ModelType.Main,
-        ui_model_base=BaseModelType.StableDiffusionXL,
+        ui_type=UIType.SDXLMainModel,
     )
 
     _validate_custom_label = model_validator(mode="after")(validate_custom_label)

invokeai/app/invocations/model.py

@@ -9,7 +9,7 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, ImageField, Input, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, ImageField, Input, InputField, OutputField, UIType
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.shared.models import FreeUConfig
 from invokeai.backend.model_manager.config import (
@@ -145,7 +145,7 @@ class ModelIdentifierInvocation(BaseInvocation):
 
 @invocation(
     "main_model_loader",
-    title="Main Model - SD1.5, SD2",
+    title="Main Model - SD1.5",
     tags=["model"],
     category="model",
     version="1.0.4",
@@ -153,11 +153,7 @@ class ModelIdentifierInvocation(BaseInvocation):
 class MainModelLoaderInvocation(BaseInvocation):
     """Loads a main model, outputting its submodels."""
 
-    model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.main_model,
-        ui_model_base=[BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2],
-        ui_model_type=ModelType.Main,
-    )
+    model: ModelIdentifierField = InputField(description=FieldDescriptions.main_model, ui_type=UIType.MainModel)
     # TODO: precision?
 
     def invoke(self, context: InvocationContext) -> ModelLoaderOutput:
@@ -191,10 +187,7 @@ class LoRALoaderInvocation(BaseInvocation):
     """Apply selected lora to unet and text_encoder."""
 
     lora: ModelIdentifierField = InputField(
-        description=FieldDescriptions.lora_model,
-        title="LoRA",
-        ui_model_base=BaseModelType.StableDiffusion1,
-        ui_model_type=ModelType.LoRA,
+        description=FieldDescriptions.lora_model, title="LoRA", ui_type=UIType.LoRAModel
     )
     weight: float = InputField(default=0.75, description=FieldDescriptions.lora_weight)
     unet: Optional[UNetField] = InputField(
@@ -257,9 +250,7 @@ class LoRASelectorInvocation(BaseInvocation):
     """Selects a LoRA model and weight."""
 
     lora: ModelIdentifierField = InputField(
-        description=FieldDescriptions.lora_model,
-        title="LoRA",
-        ui_model_type=ModelType.LoRA,
+        description=FieldDescriptions.lora_model, title="LoRA", ui_type=UIType.LoRAModel
     )
     weight: float = InputField(default=0.75, description=FieldDescriptions.lora_weight)
 
@@ -341,10 +332,7 @@ class SDXLLoRALoaderInvocation(BaseInvocation):
     """Apply selected lora to unet and text_encoder."""
 
     lora: ModelIdentifierField = InputField(
-        description=FieldDescriptions.lora_model,
-        title="LoRA",
-        ui_model_base=BaseModelType.StableDiffusionXL,
-        ui_model_type=ModelType.LoRA,
+        description=FieldDescriptions.lora_model, title="LoRA", ui_type=UIType.LoRAModel
     )
     weight: float = InputField(default=0.75, description=FieldDescriptions.lora_weight)
     unet: Optional[UNetField] = InputField(
@@ -485,26 +473,13 @@ class SDXLLoRACollectionLoader(BaseInvocation):
 
 
 @invocation(
-    "vae_loader",
-    title="VAE Model - SD1.5, SD2, SDXL, SD3, FLUX",
-    tags=["vae", "model"],
-    category="model",
-    version="1.0.4",
+    "vae_loader", title="VAE Model - SD1.5, SDXL, SD3, FLUX", tags=["vae", "model"], category="model", version="1.0.4"
 )
 class VAELoaderInvocation(BaseInvocation):
     """Loads a VAE model, outputting a VaeLoaderOutput"""
 
     vae_model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.vae_model,
-        title="VAE",
-        ui_model_base=[
-            BaseModelType.StableDiffusion1,
-            BaseModelType.StableDiffusion2,
-            BaseModelType.StableDiffusionXL,
-            BaseModelType.StableDiffusion3,
-            BaseModelType.Flux,
-        ],
-        ui_model_type=ModelType.VAE,
+        description=FieldDescriptions.vae_model, title="VAE", ui_type=UIType.VAEModel
     )
 
     def invoke(self, context: InvocationContext) -> VAEOutput:

invokeai/app/invocations/sd3_model_loader.py

@@ -6,14 +6,14 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField, UIType
 from invokeai.app.invocations.model import CLIPField, ModelIdentifierField, T5EncoderField, TransformerField, VAEField
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.t5_model_identifier import (
     preprocess_t5_encoder_model_identifier,
     preprocess_t5_tokenizer_model_identifier,
 )
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ClipVariantType, ModelType, SubModelType
+from invokeai.backend.model_manager.taxonomy import SubModelType
 
 
 @invocation_output("sd3_model_loader_output")
@@ -39,43 +39,36 @@ class Sd3ModelLoaderInvocation(BaseInvocation):
 
     model: ModelIdentifierField = InputField(
         description=FieldDescriptions.sd3_model,
+        ui_type=UIType.SD3MainModel,
         input=Input.Direct,
-        ui_model_base=BaseModelType.StableDiffusion3,
-        ui_model_type=ModelType.Main,
     )
 
     t5_encoder_model: Optional[ModelIdentifierField] = InputField(
         description=FieldDescriptions.t5_encoder,
+        ui_type=UIType.T5EncoderModel,
         input=Input.Direct,
         title="T5 Encoder",
         default=None,
-        ui_model_type=ModelType.T5Encoder,
     )
 
     clip_l_model: Optional[ModelIdentifierField] = InputField(
         description=FieldDescriptions.clip_embed_model,
+        ui_type=UIType.CLIPLEmbedModel,
         input=Input.Direct,
         title="CLIP L Encoder",
         default=None,
-        ui_model_type=ModelType.CLIPEmbed,
-        ui_model_variant=ClipVariantType.L,
     )
 
     clip_g_model: Optional[ModelIdentifierField] = InputField(
         description=FieldDescriptions.clip_g_model,
+        ui_type=UIType.CLIPGEmbedModel,
         input=Input.Direct,
         title="CLIP G Encoder",
         default=None,
-        ui_model_type=ModelType.CLIPEmbed,
-        ui_model_variant=ClipVariantType.G,
     )
 
     vae_model: Optional[ModelIdentifierField] = InputField(
-        description=FieldDescriptions.vae_model,
-        title="VAE",
-        default=None,
-        ui_model_base=BaseModelType.StableDiffusion3,
-        ui_model_type=ModelType.VAE,
+        description=FieldDescriptions.vae_model, ui_type=UIType.VAEModel, title="VAE", default=None
     )
 
     def invoke(self, context: InvocationContext) -> Sd3ModelLoaderOutput:

invokeai/app/invocations/sdxl.py

@@ -1,8 +1,8 @@
 from invokeai.app.invocations.baseinvocation import BaseInvocation, BaseInvocationOutput, invocation, invocation_output
-from invokeai.app.invocations.fields import FieldDescriptions, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, InputField, OutputField, UIType
 from invokeai.app.invocations.model import CLIPField, ModelIdentifierField, UNetField, VAEField
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType, SubModelType
+from invokeai.backend.model_manager.taxonomy import SubModelType
 
 
 @invocation_output("sdxl_model_loader_output")
@@ -29,9 +29,7 @@ class SDXLModelLoaderInvocation(BaseInvocation):
     """Loads an sdxl base model, outputting its submodels."""
 
     model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.sdxl_main_model,
-        ui_model_base=BaseModelType.StableDiffusionXL,
-        ui_model_type=ModelType.Main,
+        description=FieldDescriptions.sdxl_main_model, ui_type=UIType.SDXLMainModel
     )
     # TODO: precision?
 
@@ -69,9 +67,7 @@ class SDXLRefinerModelLoaderInvocation(BaseInvocation):
     """Loads an sdxl refiner model, outputting its submodels."""
 
     model: ModelIdentifierField = InputField(
-        description=FieldDescriptions.sdxl_refiner_model,
-        ui_model_base=BaseModelType.StableDiffusionXLRefiner,
-        ui_model_type=ModelType.Main,
+        description=FieldDescriptions.sdxl_refiner_model, ui_type=UIType.SDXLRefinerModel
     )
     # TODO: precision?
 

invokeai/app/invocations/segment_anything.py

@@ -1,75 +1,72 @@
-from itertools import zip_longest
+from enum import Enum
 from pathlib import Path
 from typing import Literal
 
 import numpy as np
 import torch
 from PIL import Image
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, Field
+from transformers import AutoProcessor
 from transformers.models.sam import SamModel
 from transformers.models.sam.processing_sam import SamProcessor
-from transformers.models.sam2 import Sam2Model
-from transformers.models.sam2.processing_sam2 import Sam2Processor
 
 from invokeai.app.invocations.baseinvocation import BaseInvocation, invocation
 from invokeai.app.invocations.fields import BoundingBoxField, ImageField, InputField, TensorField
 from invokeai.app.invocations.primitives import MaskOutput
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.image_util.segment_anything.mask_refinement import mask_to_polygon, polygon_to_mask
-from invokeai.backend.image_util.segment_anything.segment_anything_2_pipeline import SegmentAnything2Pipeline
 from invokeai.backend.image_util.segment_anything.segment_anything_pipeline import SegmentAnythingPipeline
-from invokeai.backend.image_util.segment_anything.shared import SAMInput, SAMPoint
 
-SegmentAnythingModelKey = Literal[
-    "segment-anything-base",
-    "segment-anything-large",
-    "segment-anything-huge",
-    "segment-anything-2-tiny",
-    "segment-anything-2-small",
-    "segment-anything-2-base",
-    "segment-anything-2-large",
-]
+SegmentAnythingModelKey = Literal["segment-anything-base", "segment-anything-large", "segment-anything-huge"]
 SEGMENT_ANYTHING_MODEL_IDS: dict[SegmentAnythingModelKey, str] = {
     "segment-anything-base": "facebook/sam-vit-base",
     "segment-anything-large": "facebook/sam-vit-large",
     "segment-anything-huge": "facebook/sam-vit-huge",
-    "segment-anything-2-tiny": "facebook/sam2.1-hiera-tiny",
-    "segment-anything-2-small": "facebook/sam2.1-hiera-small",
-    "segment-anything-2-base": "facebook/sam2.1-hiera-base-plus",
-    "segment-anything-2-large": "facebook/sam2.1-hiera-large",
 }
 
 
-class SAMPointsField(BaseModel):
-    points: list[SAMPoint] = Field(..., description="The points of the object", min_length=1)
+class SAMPointLabel(Enum):
+    negative = -1
+    neutral = 0
+    positive = 1
 
-    def to_list(self) -> list[list[float]]:
+
+class SAMPoint(BaseModel):
+    x: int = Field(..., description="The x-coordinate of the point")
+    y: int = Field(..., description="The y-coordinate of the point")
+    label: SAMPointLabel = Field(..., description="The label of the point")
+
+
+class SAMPointsField(BaseModel):
+    points: list[SAMPoint] = Field(..., description="The points of the object")
+
+    def to_list(self) -> list[list[int]]:
         return [[point.x, point.y, point.label.value] for point in self.points]
 
 
 @invocation(
     "segment_anything",
     title="Segment Anything",
-    tags=["prompt", "segmentation", "sam", "sam2"],
+    tags=["prompt", "segmentation"],
     category="segmentation",
-    version="1.3.0",
+    version="1.2.0",
 )
 class SegmentAnythingInvocation(BaseInvocation):
-    """Runs a Segment Anything Model (SAM or SAM2)."""
+    """Runs a Segment Anything Model."""
 
     # Reference:
     # - https://arxiv.org/pdf/2304.02643
     # - https://huggingface.co/docs/transformers/v4.43.3/en/model_doc/grounding-dino#grounded-sam
     # - https://github.com/NielsRogge/Transformers-Tutorials/blob/a39f33ac1557b02ebfb191ea7753e332b5ca933f/Grounding%20DINO/GroundingDINO_with_Segment_Anything.ipynb
 
-    model: SegmentAnythingModelKey = InputField(description="The Segment Anything model to use (SAM or SAM2).")
+    model: SegmentAnythingModelKey = InputField(description="The Segment Anything model to use.")
     image: ImageField = InputField(description="The image to segment.")
     bounding_boxes: list[BoundingBoxField] | None = InputField(
-        default=None, description="The bounding boxes to prompt the model with."
+        default=None, description="The bounding boxes to prompt the SAM model with."
     )
     point_lists: list[SAMPointsField] | None = InputField(
         default=None,
-        description="The list of point lists to prompt the model with. Each list of points represents a single object.",
+        description="The list of point lists to prompt the SAM model with. Each list of points represents a single object.",
     )
     apply_polygon_refinement: bool = InputField(
         description="Whether to apply polygon refinement to the masks. This will smooth the edges of the masks slightly and ensure that each mask consists of a single closed polygon (before merging).",
@@ -80,18 +77,14 @@ class SegmentAnythingInvocation(BaseInvocation):
         default="all",
     )
 
-    @model_validator(mode="after")
-    def validate_points_and_boxes_len(self):
-        if self.point_lists is not None and self.bounding_boxes is not None:
-            if len(self.point_lists) != len(self.bounding_boxes):
-                raise ValueError("If both point_lists and bounding_boxes are provided, they must have the same length.")
-        return self
-
     @torch.no_grad()
     def invoke(self, context: InvocationContext) -> MaskOutput:
         # The models expect a 3-channel RGB image.
         image_pil = context.images.get_pil(self.image.image_name, mode="RGB")
 
+        if self.point_lists is not None and self.bounding_boxes is not None:
+            raise ValueError("Only one of point_lists or bounding_box can be provided.")
+
         if (not self.bounding_boxes or len(self.bounding_boxes) == 0) and (
             not self.point_lists or len(self.point_lists) == 0
         ):
@@ -118,38 +111,26 @@ class SegmentAnythingInvocation(BaseInvocation):
             # model, and figure out how to make it work in the pipeline.
             # torch_dtype=TorchDevice.choose_torch_dtype(),
         )
-        sam_processor = SamProcessor.from_pretrained(model_path, local_files_only=True)
+
+        sam_processor = AutoProcessor.from_pretrained(model_path, local_files_only=True)
+        assert isinstance(sam_processor, SamProcessor)
         return SegmentAnythingPipeline(sam_model=sam_model, sam_processor=sam_processor)
 
-    @staticmethod
-    def _load_sam_2_model(model_path: Path):
-        sam2_model = Sam2Model.from_pretrained(model_path, local_files_only=True)
-        sam2_processor = Sam2Processor.from_pretrained(model_path, local_files_only=True)
-        return SegmentAnything2Pipeline(sam2_model=sam2_model, sam2_processor=sam2_processor)
-
     def _segment(self, context: InvocationContext, image: Image.Image) -> list[torch.Tensor]:
-        """Use Segment Anything (SAM or SAM2) to generate masks given an image + a set of bounding boxes."""
+        """Use Segment Anything (SAM) to generate masks given an image + a set of bounding boxes."""
+        # Convert the bounding boxes to the SAM input format.
+        sam_bounding_boxes = (
+            [[bb.x_min, bb.y_min, bb.x_max, bb.y_max] for bb in self.bounding_boxes] if self.bounding_boxes else None
+        )
+        sam_points = [p.to_list() for p in self.point_lists] if self.point_lists else None
 
-        source = SEGMENT_ANYTHING_MODEL_IDS[self.model]
-        inputs: list[SAMInput] = []
-        for bbox_field, point_field in zip_longest(self.bounding_boxes or [], self.point_lists or [], fillvalue=None):
-            inputs.append(
-                SAMInput(
-                    bounding_box=bbox_field,
-                    points=point_field.points if point_field else None,
-                )
-            )
-
-        if "sam2" in source:
-            loader = SegmentAnythingInvocation._load_sam_2_model
-            with context.models.load_remote_model(source=source, loader=loader) as pipeline:
-                assert isinstance(pipeline, SegmentAnything2Pipeline)
-                masks = pipeline.segment(image=image, inputs=inputs)
-        else:
-            loader = SegmentAnythingInvocation._load_sam_model
-            with context.models.load_remote_model(source=source, loader=loader) as pipeline:
-                assert isinstance(pipeline, SegmentAnythingPipeline)
-                masks = pipeline.segment(image=image, inputs=inputs)
+        with (
+            context.models.load_remote_model(
+                source=SEGMENT_ANYTHING_MODEL_IDS[self.model], loader=SegmentAnythingInvocation._load_sam_model
+            ) as sam_pipeline,
+        ):
+            assert isinstance(sam_pipeline, SegmentAnythingPipeline)
+            masks = sam_pipeline.segment(image=image, bounding_boxes=sam_bounding_boxes, point_lists=sam_points)
 
         masks = self._process_masks(masks)
         if self.apply_polygon_refinement:

invokeai/app/invocations/spandrel_image_to_image.py

@@ -11,6 +11,7 @@ from invokeai.app.invocations.fields import (
     FieldDescriptions,
     ImageField,
     InputField,
+    UIType,
     WithBoard,
     WithMetadata,
 )
@@ -18,7 +19,6 @@ from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.primitives import ImageOutput
 from invokeai.app.services.session_processor.session_processor_common import CanceledException
 from invokeai.app.services.shared.invocation_context import InvocationContext
-from invokeai.backend.model_manager.taxonomy import ModelType
 from invokeai.backend.spandrel_image_to_image_model import SpandrelImageToImageModel
 from invokeai.backend.tiles.tiles import calc_tiles_min_overlap
 from invokeai.backend.tiles.utils import TBLR, Tile
@@ -33,7 +33,7 @@ class SpandrelImageToImageInvocation(BaseInvocation, WithMetadata, WithBoard):
     image_to_image_model: ModelIdentifierField = InputField(
         title="Image-to-Image Model",
         description=FieldDescriptions.spandrel_image_to_image_model,
-        ui_model_type=ModelType.SpandrelImageToImage,
+        ui_type=UIType.SpandrelImageToImageModel,
     )
     tile_size: int = InputField(
         default=512, description="The tile size for tiled image-to-image. Set to 0 to disable tiling."

invokeai/app/invocations/t2i_adapter.py

@@ -8,12 +8,11 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, ImageField, InputField, OutputField, UIType
 from invokeai.app.invocations.model import ModelIdentifierField
 from invokeai.app.invocations.util import validate_begin_end_step, validate_weights
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.controlnet_utils import CONTROLNET_RESIZE_VALUES
-from invokeai.backend.model_manager.taxonomy import BaseModelType, ModelType
 
 
 class T2IAdapterField(BaseModel):
@@ -61,8 +60,7 @@ class T2IAdapterInvocation(BaseInvocation):
         description="The T2I-Adapter model.",
         title="T2I-Adapter Model",
         ui_order=-1,
-        ui_model_base=[BaseModelType.StableDiffusion1, BaseModelType.StableDiffusionXL],
-        ui_model_type=ModelType.T2IAdapter,
+        ui_type=UIType.T2IAdapterModel,
     )
     weight: Union[float, list[float]] = InputField(
         default=1, ge=0, description="The weight given to the T2I-Adapter", title="Weight"

invokeai/app/services/bulk_download/bulk_download_default.py

@@ -150,15 +150,4 @@ class BulkDownloadService(BulkDownloadBase):
     def _is_valid_path(self, path: Union[str, Path]) -> bool:
         """Validates the path given for a bulk download."""
         path = path if isinstance(path, Path) else Path(path)
-
-        # Resolve the path to handle any path traversal attempts (e.g., ../)
-        resolved_path = path.resolve()
-
-        # The path may not traverse out of the bulk downloads folder or its subfolders
-        does_not_traverse = resolved_path.parent == self._bulk_downloads_folder.resolve()
-
-        # The path must exist and be a .zip file
-        does_exist = resolved_path.exists()
-        is_zip_file = resolved_path.suffix == ".zip"
-
-        return does_exist and is_zip_file and does_not_traverse
+        return path.exists()

invokeai/app/services/events/events_common.py

@@ -234,8 +234,8 @@ class QueueItemStatusChangedEvent(QueueItemEventBase):
     error_type: Optional[str] = Field(default=None, description="The error type, if any")
     error_message: Optional[str] = Field(default=None, description="The error message, if any")
     error_traceback: Optional[str] = Field(default=None, description="The error traceback, if any")
-    created_at: str = Field(description="The timestamp when the queue item was created")
-    updated_at: str = Field(description="The timestamp when the queue item was last updated")
+    created_at: Optional[str] = Field(default=None, description="The timestamp when the queue item was created")
+    updated_at: Optional[str] = Field(default=None, description="The timestamp when the queue item was last updated")
     started_at: Optional[str] = Field(default=None, description="The timestamp when the queue item was started")
     completed_at: Optional[str] = Field(default=None, description="The timestamp when the queue item was completed")
     batch_status: BatchStatus = Field(description="The status of the batch")
@@ -258,8 +258,8 @@ class QueueItemStatusChangedEvent(QueueItemEventBase):
             error_type=queue_item.error_type,
             error_message=queue_item.error_message,
             error_traceback=queue_item.error_traceback,
-            created_at=str(queue_item.created_at),
-            updated_at=str(queue_item.updated_at),
+            created_at=str(queue_item.created_at) if queue_item.created_at else None,
+            updated_at=str(queue_item.updated_at) if queue_item.updated_at else None,
             started_at=str(queue_item.started_at) if queue_item.started_at else None,
             completed_at=str(queue_item.completed_at) if queue_item.completed_at else None,
             batch_status=batch_status,

invokeai/app/services/session_queue/session_queue_base.py

@@ -15,7 +15,6 @@ from invokeai.app.services.session_queue.session_queue_common import (
     EnqueueBatchResult,
     IsEmptyResult,
     IsFullResult,
-    ItemIdsResult,
     PruneResult,
     RetryItemsResult,
     SessionQueueCountsByDestination,
@@ -24,7 +23,6 @@ from invokeai.app.services.session_queue.session_queue_common import (
 )
 from invokeai.app.services.shared.graph import GraphExecutionState
 from invokeai.app.services.shared.pagination import CursorPaginatedResults
-from invokeai.app.services.shared.sqlite.sqlite_common import SQLiteDirection
 
 
 class SessionQueueBase(ABC):
@@ -147,7 +145,7 @@ class SessionQueueBase(ABC):
         status: Optional[QUEUE_ITEM_STATUS] = None,
         destination: Optional[str] = None,
     ) -> CursorPaginatedResults[SessionQueueItem]:
-        """Gets a page of session queue items. Do not remove."""
+        """Gets a page of session queue items"""
         pass
 
     @abstractmethod
@@ -159,18 +157,9 @@ class SessionQueueBase(ABC):
         """Gets all queue items that match the given parameters"""
         pass
 
-    @abstractmethod
-    def get_queue_item_ids(
-        self,
-        queue_id: str,
-        order_dir: SQLiteDirection = SQLiteDirection.Descending,
-    ) -> ItemIdsResult:
-        """Gets all queue item ids that match the given parameters"""
-        pass
-
     @abstractmethod
     def get_queue_item(self, item_id: int) -> SessionQueueItem:
-        """Gets a session queue item by ID for a given queue"""
+        """Gets a session queue item by ID"""
         pass
 
     @abstractmethod

invokeai/app/services/session_queue/session_queue_common.py

@@ -176,14 +176,6 @@ DEFAULT_QUEUE_ID = "default"
 
 QUEUE_ITEM_STATUS = Literal["pending", "in_progress", "completed", "failed", "canceled"]
 
-
-class ItemIdsResult(BaseModel):
-    """Response containing ordered item ids with metadata for optimistic updates."""
-
-    item_ids: list[int] = Field(description="Ordered list of item ids")
-    total_count: int = Field(description="Total number of queue items matching the query")
-
-
 NodeFieldValueValidator = TypeAdapter(list[NodeFieldValue])
 
 

invokeai/app/services/session_queue/session_queue_sqlite.py

@@ -22,7 +22,6 @@ from invokeai.app.services.session_queue.session_queue_common import (
     EnqueueBatchResult,
     IsEmptyResult,
     IsFullResult,
-    ItemIdsResult,
     PruneResult,
     RetryItemsResult,
     SessionQueueCountsByDestination,
@@ -35,7 +34,6 @@ from invokeai.app.services.session_queue.session_queue_common import (
 )
 from invokeai.app.services.shared.graph import GraphExecutionState
 from invokeai.app.services.shared.pagination import CursorPaginatedResults
-from invokeai.app.services.shared.sqlite.sqlite_common import SQLiteDirection
 from invokeai.app.services.shared.sqlite.sqlite_database import SqliteDatabase
 
 
@@ -673,26 +671,6 @@ class SqliteSessionQueue(SessionQueueBase):
         items = [SessionQueueItem.queue_item_from_dict(dict(result)) for result in results]
         return items
 
-    def get_queue_item_ids(
-        self,
-        queue_id: str,
-        order_dir: SQLiteDirection = SQLiteDirection.Descending,
-    ) -> ItemIdsResult:
-        with self._db.transaction() as cursor_:
-            query = f"""--sql
-                SELECT item_id
-                FROM session_queue
-                WHERE queue_id = ?
-                ORDER BY created_at {order_dir.value}
-                """
-            query_params = [queue_id]
-
-            cursor_.execute(query, query_params)
-            result = cast(list[sqlite3.Row], cursor_.fetchall())
-        item_ids = [row[0] for row in result]
-
-        return ItemIdsResult(item_ids=item_ids, total_count=len(item_ids))
-
     def get_queue_status(self, queue_id: str) -> SessionQueueStatus:
         with self._db.transaction() as cursor:
             cursor.execute(

invokeai/backend/image_util/segment_anything/segment_anything_2_pipeline.py

@@ -1,109 +0,0 @@
-from typing import Optional
-
-import torch
-from PIL import Image
-
-# Import SAM2 components - these should be available in transformers 4.56.0+
-from transformers.models.sam2 import Sam2Model
-from transformers.models.sam2.processing_sam2 import Sam2Processor
-
-from invokeai.backend.image_util.segment_anything.shared import SAMInput
-from invokeai.backend.raw_model import RawModel
-
-
-class SegmentAnything2Pipeline(RawModel):
-    """A wrapper class for the transformers SAM2 model and processor that makes it compatible with the model manager."""
-
-    def __init__(self, sam2_model: Sam2Model, sam2_processor: Sam2Processor):
-        """Initialize the SAM2 pipeline.
-
-        Args:
-            sam2_model: The SAM2 model
-            sam2_processor: The SAM2 processor (can be Sam2Processor or Sam2VideoProcessor)
-        """
-        self._sam2_model = sam2_model
-        self._sam2_processor = sam2_processor
-
-    def to(self, device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None):
-        # HACK: The SAM2 pipeline may not work on MPS devices. We only allow it to be moved to CPU or CUDA.
-        if device is not None and device.type not in {"cpu", "cuda"}:
-            device = None
-        self._sam2_model.to(device=device, dtype=dtype)
-
-    def calc_size(self) -> int:
-        # HACK: Fix the circular import issue.
-        from invokeai.backend.model_manager.load.model_util import calc_module_size
-
-        return calc_module_size(self._sam2_model)
-
-    def segment(
-        self,
-        image: Image.Image,
-        inputs: list[SAMInput],
-    ) -> torch.Tensor:
-        """Segment the image using the provided inputs.
-
-        Args:
-            image: The image to segment.
-            inputs: A list of SAMInput objects containing bounding boxes and/or point lists.
-
-        Returns:
-            torch.Tensor: The segmentation masks. dtype: torch.bool. shape: [num_masks, channels, height, width].
-        """
-
-        input_boxes: list[list[float]] = []
-        input_points: list[list[list[float]]] = []
-        input_labels: list[list[int]] = []
-
-        for i in inputs:
-            box: list[float] | None = None
-            points: list[list[float]] | None = None
-            labels: list[int] | None = None
-
-            if i.bounding_box is not None:
-                box: list[float] | None = [
-                    i.bounding_box.x_min,
-                    i.bounding_box.y_min,
-                    i.bounding_box.x_max,
-                    i.bounding_box.y_max,
-                ]
-
-            if i.points is not None:
-                points = []
-                labels = []
-                for point in i.points:
-                    points.append([point.x, point.y])
-                    labels.append(point.label.value)
-
-            if box is not None:
-                input_boxes.append(box)
-            if points is not None:
-                input_points.append(points)
-            if labels is not None:
-                input_labels.append(labels)
-
-        batched_input_boxes = [input_boxes] if input_boxes else None
-        batched_input_points = [input_points] if input_points else None
-        batched_input_labels = [input_labels] if input_labels else None
-
-        processed_inputs = self._sam2_processor(
-            images=image,
-            input_boxes=batched_input_boxes,
-            input_points=batched_input_points,
-            input_labels=batched_input_labels,
-            return_tensors="pt",
-        ).to(self._sam2_model.device)
-
-        # Generate masks using the SAM2 model
-        outputs = self._sam2_model(**processed_inputs)
-
-        # Post-process the masks to get the final segmentation
-        masks = self._sam2_processor.post_process_masks(
-            masks=outputs.pred_masks,
-            original_sizes=processed_inputs.original_sizes,
-            reshaped_input_sizes=processed_inputs.reshaped_input_sizes,
-        )
-
-        # There should be only one batch.
-        assert len(masks) == 1
-        return masks[0]

invokeai/backend/image_util/segment_anything/segment_anything_pipeline.py

@@ -1,13 +1,20 @@
-from typing import Optional
+from typing import Optional, TypeAlias
 
 import torch
 from PIL import Image
 from transformers.models.sam import SamModel
 from transformers.models.sam.processing_sam import SamProcessor
 
-from invokeai.backend.image_util.segment_anything.shared import SAMInput
 from invokeai.backend.raw_model import RawModel
 
+# Type aliases for the inputs to the SAM model.
+ListOfBoundingBoxes: TypeAlias = list[list[int]]
+"""A list of bounding boxes. Each bounding box is in the format [xmin, ymin, xmax, ymax]."""
+ListOfPoints: TypeAlias = list[list[int]]
+"""A list of points. Each point is in the format [x, y]."""
+ListOfPointLabels: TypeAlias = list[int]
+"""A list of SAM point labels. Each label is an integer where -1 is background, 0 is neutral, and 1 is foreground."""
+
 
 class SegmentAnythingPipeline(RawModel):
     """A wrapper class for the transformers SAM model and processor that makes it compatible with the model manager."""
@@ -31,65 +38,55 @@ class SegmentAnythingPipeline(RawModel):
     def segment(
         self,
         image: Image.Image,
-        inputs: list[SAMInput],
+        bounding_boxes: list[list[int]] | None = None,
+        point_lists: list[list[list[int]]] | None = None,
     ) -> torch.Tensor:
-        """Segment the image using the provided inputs.
+        """Run the SAM model.
+
+        Either bounding_boxes or point_lists must be provided. If both are provided, bounding_boxes will be used and
+        point_lists will be ignored.
 
         Args:
-            image: The image to segment.
-            inputs: A list of SAMInput objects containing bounding boxes and/or point lists.
+            image (Image.Image): The image to segment.
+            bounding_boxes (list[list[int]]): The bounding box prompts. Each bounding box is in the format
+                [xmin, ymin, xmax, ymax].
+            point_lists (list[list[list[int]]]): The points prompts. Each point is in the format [x, y, label].
+                `label` is an integer where -1 is background, 0 is neutral, and 1 is foreground.
 
         Returns:
             torch.Tensor: The segmentation masks. dtype: torch.bool. shape: [num_masks, channels, height, width].
         """
 
-        input_boxes: list[list[float]] = []
-        input_points: list[list[list[float]]] = []
-        input_labels: list[list[int]] = []
+        # Prep the inputs:
+        # - Create a list of bounding boxes or points and labels.
+        # - Add a batch dimension of 1 to the inputs.
+        if bounding_boxes:
+            input_boxes: list[ListOfBoundingBoxes] | None = [bounding_boxes]
+            input_points: list[ListOfPoints] | None = None
+            input_labels: list[ListOfPointLabels] | None = None
+        elif point_lists:
+            input_boxes: list[ListOfBoundingBoxes] | None = None
+            input_points: list[ListOfPoints] | None = []
+            input_labels: list[ListOfPointLabels] | None = []
+            for point_list in point_lists:
+                input_points.append([[p[0], p[1]] for p in point_list])
+                input_labels.append([p[2] for p in point_list])
 
-        for i in inputs:
-            box: list[float] | None = None
-            points: list[list[float]] | None = None
-            labels: list[int] | None = None
+        else:
+            raise ValueError("Either bounding_boxes or points and labels must be provided.")
 
-            if i.bounding_box is not None:
-                box: list[float] | None = [
-                    i.bounding_box.x_min,
-                    i.bounding_box.y_min,
-                    i.bounding_box.x_max,
-                    i.bounding_box.y_max,
-                ]
-
-            if i.points is not None:
-                points = []
-                labels = []
-                for point in i.points:
-                    points.append([point.x, point.y])
-                    labels.append(point.label.value)
-
-            if box is not None:
-                input_boxes.append(box)
-            if points is not None:
-                input_points.append(points)
-            if labels is not None:
-                input_labels.append(labels)
-
-        batched_input_boxes = [input_boxes] if input_boxes else None
-        batched_input_points = input_points if input_points else None
-        batched_input_labels = input_labels if input_labels else None
-
-        processed_inputs = self._sam_processor(
+        inputs = self._sam_processor(
             images=image,
-            input_boxes=batched_input_boxes,
-            input_points=batched_input_points,
-            input_labels=batched_input_labels,
+            input_boxes=input_boxes,
+            input_points=input_points,
+            input_labels=input_labels,
             return_tensors="pt",
         ).to(self._sam_model.device)
-        outputs = self._sam_model(**processed_inputs)
+        outputs = self._sam_model(**inputs)
         masks = self._sam_processor.post_process_masks(
             masks=outputs.pred_masks,
-            original_sizes=processed_inputs.original_sizes,
-            reshaped_input_sizes=processed_inputs.reshaped_input_sizes,
+            original_sizes=inputs.original_sizes,
+            reshaped_input_sizes=inputs.reshaped_input_sizes,
         )
 
         # There should be only one batch.

invokeai/backend/image_util/segment_anything/shared.py

@@ -1,49 +0,0 @@
-from enum import Enum
-
-from pydantic import BaseModel, model_validator
-from pydantic.fields import Field
-
-
-class BoundingBox(BaseModel):
-    x_min: int = Field(..., description="The minimum x-coordinate of the bounding box (inclusive).")
-    x_max: int = Field(..., description="The maximum x-coordinate of the bounding box (exclusive).")
-    y_min: int = Field(..., description="The minimum y-coordinate of the bounding box (inclusive).")
-    y_max: int = Field(..., description="The maximum y-coordinate of the bounding box (exclusive).")
-
-    @model_validator(mode="after")
-    def check_coords(self):
-        if self.x_min > self.x_max:
-            raise ValueError(f"x_min ({self.x_min}) is greater than x_max ({self.x_max}).")
-        if self.y_min > self.y_max:
-            raise ValueError(f"y_min ({self.y_min}) is greater than y_max ({self.y_max}).")
-        return self
-
-    def tuple(self) -> tuple[int, int, int, int]:
-        """
-        Returns the bounding box as a tuple suitable for use with PIL's `Image.crop()` method.
-        This method returns a tuple of the form (left, upper, right, lower) == (x_min, y_min, x_max, y_max).
-        """
-        return (self.x_min, self.y_min, self.x_max, self.y_max)
-
-
-class SAMPointLabel(Enum):
-    negative = -1
-    neutral = 0
-    positive = 1
-
-
-class SAMPoint(BaseModel):
-    x: int = Field(..., description="The x-coordinate of the point")
-    y: int = Field(..., description="The y-coordinate of the point")
-    label: SAMPointLabel = Field(..., description="The label of the point")
-
-
-class SAMInput(BaseModel):
-    bounding_box: BoundingBox | None = Field(None, description="The bounding box to use for segmentation")
-    points: list[SAMPoint] | None = Field(None, description="The points to use for segmentation")
-
-    @model_validator(mode="after")
-    def check_input(self):
-        if not self.bounding_box and not self.points:
-            raise ValueError("Either bounding_box or points must be provided")
-        return self

invokeai/backend/ip_adapter/ip_adapter.py

@@ -207,24 +207,15 @@ class IPAdapterPlusXL(IPAdapterPlus):
 
 
 def load_ip_adapter_tensors(ip_adapter_ckpt_path: pathlib.Path, device: str) -> IPAdapterStateDict:
-    state_dict: IPAdapterStateDict = {
-        "ip_adapter": {},
-        "image_proj": {},
-        "adapter_modules": {},  # added for noobai-mark-ipa
-        "image_proj_model": {},  # added for noobai-mark-ipa
-    }
+    state_dict: IPAdapterStateDict = {"ip_adapter": {}, "image_proj": {}}
 
     if ip_adapter_ckpt_path.suffix == ".safetensors":
         model = safetensors.torch.load_file(ip_adapter_ckpt_path, device=device)
         for key in model.keys():
-            if key.startswith("ip_adapter."):
-                state_dict["ip_adapter"][key.replace("ip_adapter.", "")] = model[key]
-            elif key.startswith("image_proj_model."):
-                state_dict["image_proj_model"][key.replace("image_proj_model.", "")] = model[key]
-            elif key.startswith("image_proj."):
+            if key.startswith("image_proj."):
                 state_dict["image_proj"][key.replace("image_proj.", "")] = model[key]
-            elif key.startswith("adapter_modules."):
-                state_dict["adapter_modules"][key.replace("adapter_modules.", "")] = model[key]
+            elif key.startswith("ip_adapter."):
+                state_dict["ip_adapter"][key.replace("ip_adapter.", "")] = model[key]
             else:
                 raise RuntimeError(f"Encountered unexpected IP Adapter state dict key: '{key}'.")
     else:

invokeai/frontend/web/CLAUDE.md

@@ -1,39 +0,0 @@
-# Bash commands
-
-All commands should be run from `<REPO_ROOT>/invokeai/frontend/web/`.
-
-- `pnpm lint:prettier`: check formatting
-- `pnpm lint:eslint`: check for linting issues
-- `pnpm lint:knip`: check for unused dependencies
-- `pnpm lint:dpdm`: check for dependency cycles
-- `pnpm lint:tsc`: check for TypeScript issues
-- `pnpm lint`: run all checks
-- `pnpm fix`: automatically fix issues where possible
-- `pnpm test:no-watch`: run the test suite
-
-# Writing Tests
-
-This repo uses `vitest` for unit tests.
-
-Tests should be colocated with the code they test, and should use the `.test.ts` suffix.
-
-Tests do not need to be written for code that is trivial or has no logic (e.g. simple type definitions, re-exports, etc.). We currently do not do UI tests.
-
-# Agents
-
-- Use @agent-javascript-pro and @agent-typescript-pro for JavaScript and TypeScript code generation and assistance.
-- Use @frontend-developer for general frontend development tasks.
-
-## Workflow
-
-Split up tasks into smaller subtasks and handle them one at a time using an agent. Ensure each subtask is completed before moving on to the next.
-
-Each agent should maintain a work log in a markdown file.
-
-When an agent completes a task, it should:
-
-1. Summarize the changes made.
-2. List any files that were added, modified, or deleted.
-3. Commit the changes with a descriptive commit message.
-
-DO NOT PUSH ANY CHANGES TO THE REMOTE REPOSITORY.

invokeai/frontend/web/package.json

@@ -45,7 +45,7 @@
     "@dagrejs/dagre": "^1.1.5",
     "@dagrejs/graphlib": "^2.2.4",
     "@fontsource-variable/inter": "^5.2.6",
-    "@invoke-ai/ui-library": "^0.0.47",
+    "@invoke-ai/ui-library": "^0.0.46",
     "@nanostores/react": "^1.0.0",
     "@observ33r/object-equals": "^1.1.5",
     "@reduxjs/toolkit": "2.8.2",

invokeai/frontend/web/pnpm-lock.yaml

@@ -27,8 +27,8 @@ importers:
         specifier: ^5.2.6
         version: 5.2.6
       '@invoke-ai/ui-library':
-        specifier: ^0.0.47
-        version: 0.0.47(@chakra-ui/system@2.6.2(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@emotion/styled@11.14.1(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react@18.3.1))(react@18.3.1))(@fontsource-variable/inter@5.2.6)(@types/react@18.3.23)(i18next@25.3.2(typescript@5.8.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.8.3)
+        specifier: ^0.0.46
+        version: 0.0.46(@chakra-ui/system@2.6.2(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@emotion/styled@11.14.1(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react@18.3.1))(react@18.3.1))(@fontsource-variable/inter@5.2.6)(@types/react@18.3.23)(i18next@25.3.2(typescript@5.8.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.8.3)
       '@nanostores/react':
         specifier: ^1.0.0
         version: 1.0.0(nanostores@1.0.1)(react@18.3.1)
@@ -887,8 +887,8 @@ packages:
     resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
     engines: {node: '>=18.18'}
 
-  '@invoke-ai/ui-library@0.0.47':
-    resolution: {integrity: sha512-zmO2bAkkqT2yhkHjrsDnYio3YNKYyBSJXDZFmTSxWdK58UM2+Zq3h7cpVbDgS7Dzo4RXdF7p+DdlYPm2iIey5A==}
+  '@invoke-ai/ui-library@0.0.46':
+    resolution: {integrity: sha512-3YBuWWhRbTUHi0RZKeyvDEvweoyZmeBdUGJIhemjdAgGx6l98rAMeCs8IQH+SYjSAIhiGRGf45fQ33PDK8Jkmw==}
     peerDependencies:
       '@fontsource-variable/inter': ^5.0.16
       react: ^18.2.0
@@ -968,6 +968,13 @@ packages:
   '@mux/playback-core@0.30.1':
     resolution: {integrity: sha512-rnO1NE9xHDyzbAkmE6ygJYcD7cyyMt7xXqWTykxlceaoSXLjUqgp42HDio7Lcidto4x/O4FIa7ztjV2aCBCXgQ==}
 
+  '@nanostores/react@0.7.3':
+    resolution: {integrity: sha512-/XuLAMENRu/Q71biW4AZ4qmU070vkZgiQ28gaTSNRPm2SZF5zGAR81zPE1MaMB4SeOp6ZTst92NBaG75XSspNg==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    peerDependencies:
+      nanostores: ^0.9.0 || ^0.10.0 || ^0.11.0
+      react: '>=18.0.0'
+
   '@nanostores/react@1.0.0':
     resolution: {integrity: sha512-eDduyNy+lbQJMg6XxZ/YssQqF6b4OXMFEZMYKPJCCmBevp1lg0g+4ZRi94qGHirMtsNfAWKNwsjOhC+q1gvC+A==}
     engines: {node: ^20.0.0 || >=22.0.0}
@@ -2416,9 +2423,6 @@ packages:
     resolution: {integrity: sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==}
     engines: {node: '>= 0.4'}
 
-  es-toolkit@1.39.10:
-    resolution: {integrity: sha512-E0iGnTtbDhkeczB0T+mxmoVlT4YNweEKBLq7oaU4p11mecdsZpNWOglI4895Vh4usbQ+LsJiuLuI2L0Vdmfm2w==}
-
   es-toolkit@1.39.7:
     resolution: {integrity: sha512-ek/wWryKouBrZIjkwW2BFf91CWOIMvoy2AE5YYgUrfWsJQM2Su1LoLtrw8uusEpN9RfqLlV/0FVNjT0WMv8Bxw==}
 
@@ -3194,6 +3198,9 @@ packages:
     resolution: {integrity: sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
+  lodash-es@4.17.21:
+    resolution: {integrity: sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==}
+
   lodash.merge@4.6.2:
     resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
 
@@ -3242,9 +3249,6 @@ packages:
     resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
     engines: {node: '>=10'}
 
-  math-expression-evaluator@2.0.7:
-    resolution: {integrity: sha512-uwliJZ6BPHRq4eiqNWxZBDzKUiS5RIynFFcgchqhBOloVLVBpZpNG8jRYkedLcBvhph8TnRyWEuxPqiQcwIdog==}
-
   math-intrinsics@1.1.0:
     resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
     engines: {node: '>= 0.4'}
@@ -3348,6 +3352,10 @@ packages:
     engines: {node: ^18 || >=20}
     hasBin: true
 
+  nanostores@0.11.4:
+    resolution: {integrity: sha512-k1oiVNN4hDK8NcNERSZLQiMfRzEGtfnvZvdBvey3SQbgn8Dcrk0h1I6vpxApjb10PFUflZrgJ2WEZyJQ+5v7YQ==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+
   nanostores@1.0.1:
     resolution: {integrity: sha512-kNZ9xnoJYKg/AfxjrVL4SS0fKX++4awQReGqWnwTRHxeHGZ1FJFVgTqr/eMrNQdp0Tz7M7tG/TDaX8QfHDwVCw==}
     engines: {node: ^20.0.0 || >=22.0.0}
@@ -3441,12 +3449,12 @@ packages:
       overlayscrollbars: ^2.0.0
       react: '>=16.8.0'
 
+  overlayscrollbars@2.10.0:
+    resolution: {integrity: sha512-diNMeEafWTE0A4GJfwRpdBp2rE/BEvrhptBdBcDu8/UeytWcdCy9Td8tZWnztJeJ26f8/uHCWfPnPUC/dtgJdw==}
+
   overlayscrollbars@2.11.4:
     resolution: {integrity: sha512-GKYQo3OZ1QWnppNjQVv5hfpn+glYUxc6+ufW+ivdXUyLWFNc01XoH2Z36KGM4I8e5pXYeA3ElNItcXiLvmUhnQ==}
 
-  overlayscrollbars@2.12.0:
-    resolution: {integrity: sha512-mWJ5MOkcZ/ljHwfLw8+bN0V9ziGCoNoqULcp994j5DTGNQvnkWKWkA7rnO29Kyew5AoHxUnJ4Ndqfcl0HSQjXg==}
-
   own-keys@1.0.1:
     resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
     engines: {node: '>= 0.4'}
@@ -3679,22 +3687,6 @@ packages:
       typescript:
         optional: true
 
-  react-i18next@15.7.3:
-    resolution: {integrity: sha512-AANws4tOE+QSq/IeMF/ncoHlMNZaVLxpa5uUGW1wjike68elVYr0018L9xYoqBr1OFO7G7boDPrbn0HpMCJxTw==}
-    peerDependencies:
-      i18next: '>= 25.4.1'
-      react: '>= 16.8.0'
-      react-dom: '*'
-      react-native: '*'
-      typescript: ^5
-    peerDependenciesMeta:
-      react-dom:
-        optional: true
-      react-native:
-        optional: true
-      typescript:
-        optional: true
-
   react-icons@5.5.0:
     resolution: {integrity: sha512-MEFcXdkP3dLo8uumGI5xN3lDFNsRtrjbOEKDLD7yv76v4wpnEq2Lt2qeHaQOr34I/wPN3s3+N08WkQ+CW37Xiw==}
     peerDependencies:
@@ -3751,8 +3743,8 @@ packages:
       react: ^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
       react-dom: ^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
 
-  react-select@5.10.2:
-    resolution: {integrity: sha512-Z33nHdEFWq9tfnfVXaiM12rbJmk+QjFEztWLtmXqQhz6Al4UZZ9xc0wiatmGtUOCCnHN0WizL3tCMYRENX4rVQ==}
+  react-select@5.10.1:
+    resolution: {integrity: sha512-roPEZUL4aRZDx6DcsD+ZNreVl+fM8VsKn0Wtex1v4IazH60ILp5xhdlp464IsEAlJdXeD+BhDAFsBVMfvLQueA==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
       react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
@@ -5127,7 +5119,7 @@ snapshots:
 
   '@emotion/styled@11.14.1(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react@18.3.1)':
     dependencies:
-      '@babel/runtime': 7.28.3
+      '@babel/runtime': 7.27.6
       '@emotion/babel-plugin': 11.13.5
       '@emotion/is-prop-valid': 1.3.1
       '@emotion/react': 11.14.0(@types/react@18.3.23)(react@18.3.1)
@@ -5298,7 +5290,7 @@ snapshots:
 
   '@humanwhocodes/retry@0.4.3': {}
 
-  '@invoke-ai/ui-library@0.0.47(@chakra-ui/system@2.6.2(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@emotion/styled@11.14.1(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react@18.3.1))(react@18.3.1))(@fontsource-variable/inter@5.2.6)(@types/react@18.3.23)(i18next@25.3.2(typescript@5.8.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.8.3)':
+  '@invoke-ai/ui-library@0.0.46(@chakra-ui/system@2.6.2(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@emotion/styled@11.14.1(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react@18.3.1))(react@18.3.1))(@fontsource-variable/inter@5.2.6)(@types/react@18.3.23)(i18next@25.3.2(typescript@5.8.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.8.3)':
     dependencies:
       '@chakra-ui/anatomy': 2.3.4
       '@chakra-ui/icons': 2.2.4(@chakra-ui/react@2.10.9(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@emotion/styled@11.14.1(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(framer-motion@10.18.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react@18.3.1)
@@ -5310,19 +5302,18 @@ snapshots:
       '@emotion/react': 11.14.0(@types/react@18.3.23)(react@18.3.1)
       '@emotion/styled': 11.14.1(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react@18.3.1)
       '@fontsource-variable/inter': 5.2.6
-      '@nanostores/react': 1.0.0(nanostores@1.0.1)(react@18.3.1)
+      '@nanostores/react': 0.7.3(nanostores@0.11.4)(react@18.3.1)
       chakra-react-select: 4.10.1(@chakra-ui/react@2.10.9(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@emotion/styled@11.14.1(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(framer-motion@10.18.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(@emotion/react@11.14.0(@types/react@18.3.23)(react@18.3.1))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      es-toolkit: 1.39.10
       framer-motion: 10.18.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
-      math-expression-evaluator: 2.0.7
-      nanostores: 1.0.1
-      overlayscrollbars: 2.12.0
-      overlayscrollbars-react: 0.5.6(overlayscrollbars@2.12.0)(react@18.3.1)
+      lodash-es: 4.17.21
+      nanostores: 0.11.4
+      overlayscrollbars: 2.10.0
+      overlayscrollbars-react: 0.5.6(overlayscrollbars@2.10.0)(react@18.3.1)
       react: 18.3.1
       react-dom: 18.3.1(react@18.3.1)
-      react-i18next: 15.7.3(i18next@25.3.2(typescript@5.8.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.8.3)
+      react-i18next: 15.6.0(i18next@25.3.2(typescript@5.8.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.8.3)
       react-icons: 5.5.0(react@18.3.1)
-      react-select: 5.10.2(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      react-select: 5.10.1(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
     transitivePeerDependencies:
       - '@chakra-ui/system'
       - '@types/react'
@@ -5443,6 +5434,11 @@ snapshots:
       hls.js: 1.6.9
       mux-embed: 5.11.0
 
+  '@nanostores/react@0.7.3(nanostores@0.11.4)(react@18.3.1)':
+    dependencies:
+      nanostores: 0.11.4
+      react: 18.3.1
+
   '@nanostores/react@1.0.0(nanostores@1.0.1)(react@18.3.1)':
     dependencies:
       nanostores: 1.0.1
@@ -7042,8 +7038,6 @@ snapshots:
       is-date-object: 1.1.0
       is-symbol: 1.1.1
 
-  es-toolkit@1.39.10: {}
-
   es-toolkit@1.39.7: {}
 
   esbuild-register@3.6.0(esbuild@0.25.6):
@@ -7875,6 +7869,8 @@ snapshots:
     dependencies:
       p-locate: 6.0.0
 
+  lodash-es@4.17.21: {}
+
   lodash.merge@4.6.2: {}
 
   lodash.mergewith@4.6.2: {}
@@ -7920,8 +7916,6 @@ snapshots:
     dependencies:
       semver: 7.7.2
 
-  math-expression-evaluator@2.0.7: {}
-
   math-intrinsics@1.1.0: {}
 
   mdn-data@2.0.14: {}
@@ -8018,6 +8012,8 @@ snapshots:
 
   nanoid@5.1.5: {}
 
+  nanostores@0.11.4: {}
+
   nanostores@1.0.1: {}
 
   native-promise-only@0.8.1: {}
@@ -8124,20 +8120,20 @@ snapshots:
       strip-ansi: 6.0.1
       wcwidth: 1.0.1
 
+  overlayscrollbars-react@0.5.6(overlayscrollbars@2.10.0)(react@18.3.1):
+    dependencies:
+      overlayscrollbars: 2.10.0
+      react: 18.3.1
+
   overlayscrollbars-react@0.5.6(overlayscrollbars@2.11.4)(react@18.3.1):
     dependencies:
       overlayscrollbars: 2.11.4
       react: 18.3.1
 
-  overlayscrollbars-react@0.5.6(overlayscrollbars@2.12.0)(react@18.3.1):
-    dependencies:
-      overlayscrollbars: 2.12.0
-      react: 18.3.1
+  overlayscrollbars@2.10.0: {}
 
   overlayscrollbars@2.11.4: {}
 
-  overlayscrollbars@2.12.0: {}
-
   own-keys@1.0.1:
     dependencies:
       get-intrinsic: 1.3.0
@@ -8297,7 +8293,7 @@ snapshots:
 
   react-clientside-effect@1.2.8(react@18.3.1):
     dependencies:
-      '@babel/runtime': 7.28.3
+      '@babel/runtime': 7.27.6
       react: 18.3.1
 
   react-colorful@5.6.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
@@ -8346,7 +8342,7 @@ snapshots:
 
   react-focus-lock@2.13.6(@types/react@18.3.23)(react@18.3.1):
     dependencies:
-      '@babel/runtime': 7.28.3
+      '@babel/runtime': 7.27.6
       focus-lock: 1.3.6
       prop-types: 15.8.1
       react: 18.3.1
@@ -8375,16 +8371,6 @@ snapshots:
       react-dom: 18.3.1(react@18.3.1)
       typescript: 5.8.3
 
-  react-i18next@15.7.3(i18next@25.3.2(typescript@5.8.3))(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.8.3):
-    dependencies:
-      '@babel/runtime': 7.28.3
-      html-parse-stringify: 3.0.1
-      i18next: 25.3.2(typescript@5.8.3)
-      react: 18.3.1
-    optionalDependencies:
-      react-dom: 18.3.1(react@18.3.1)
-      typescript: 5.8.3
-
   react-icons@5.5.0(react@18.3.1):
     dependencies:
       react: 18.3.1
@@ -8444,9 +8430,9 @@ snapshots:
       react: 18.3.1
       react-dom: 18.3.1(react@18.3.1)
 
-  react-select@5.10.2(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+  react-select@5.10.1(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
     dependencies:
-      '@babel/runtime': 7.28.3
+      '@babel/runtime': 7.27.6
       '@emotion/cache': 11.14.0
       '@emotion/react': 11.14.0(@types/react@18.3.23)(react@18.3.1)
       '@floating-ui/dom': 1.7.2

invokeai/frontend/web/public/locales/ar.json

@@ -14,7 +14,8 @@
     "gallery": {
         "galleryImageSize": "حجم الصورة",
         "gallerySettings": "إعدادات المعرض",
-        "autoSwitchNewImages": "التبديل التلقائي إلى الصور الجديدة"
+        "autoSwitchNewImages": "التبديل التلقائي إلى الصور الجديدة",
+        "noImagesInGallery": "لا توجد صور في المعرض"
     },
     "modelManager": {
         "modelManager": "مدير النموذج",
@@ -61,10 +62,12 @@
         "infillMethod": "طريقة التعبئة",
         "tileSize": "حجم البلاطة",
         "copyImage": "نسخ الصورة",
+        "downloadImage": "تحميل الصورة",
         "usePrompt": "استخدم المحث",
         "useSeed": "استخدام البذور",
         "useAll": "استخدام الكل",
-        "info": "معلومات"
+        "info": "معلومات",
+        "showOptionsPanel": "إظهار لوحة الخيارات"
     },
     "settings": {
         "models": "موديلات",

invokeai/frontend/web/public/locales/de.json

@@ -24,6 +24,7 @@
         "ipAdapter": "IP Adapter",
         "auto": "Auto",
         "controlNet": "ControlNet",
+        "imageFailedToLoad": "Kann Bild nicht laden",
         "modelManager": "Model Manager",
         "learnMore": "Mehr erfahren",
         "loading": "Lade",
@@ -51,6 +52,7 @@
         "somethingWentWrong": "Etwas ist schief gelaufen",
         "copyError": "$t(gallery.copy) Fehler",
         "input": "Eingabe",
+        "notInstalled": "Nicht $t(common.installed)",
         "alpha": "Alpha",
         "red": "Rot",
         "green": "Grün",
@@ -60,8 +62,11 @@
         "direction": "Richtung",
         "save": "Speichern",
         "created": "Erstellt",
+        "prevPage": "Vorherige Seite",
+        "nextPage": "Nächste Seite",
         "unknownError": "Unbekannter Fehler",
         "aboutDesc": "Verwenden Sie Invoke für die Arbeit? Siehe hier:",
+        "localSystem": "Lokales System",
         "orderBy": "Ordnen nach",
         "saveAs": "Speichern als",
         "updated": "Aktualisiert",
@@ -72,6 +77,7 @@
         "selected": "Ausgewählt",
         "beta": "Beta",
         "editor": "Editor",
+        "goTo": "Gehe zu",
         "positivePrompt": "Positiv-Prompt",
         "negativePrompt": "Negativ-Prompt",
         "tab": "Tabulator",
@@ -100,6 +106,7 @@
         "values": "Werte",
         "min": "Min",
         "max": "Max",
+        "resetToDefaults": "Auf Standard zurücksetzen",
         "seed": "Seed",
         "row": "Reihe",
         "column": "Spalte",
@@ -128,12 +135,14 @@
         "galleryImageSize": "Bildgröße",
         "gallerySettings": "Galerie-Einstellungen",
         "autoSwitchNewImages": "Auto-Wechsel zu neuen Bildern",
+        "noImagesInGallery": "Keine Bilder in der Galerie",
         "loading": "Lade",
         "deleteImage_one": "Lösche Bild",
         "deleteImage_other": "Lösche {{count}} Bilder",
         "copy": "Kopieren",
         "download": "Runterladen",
         "featuresWillReset": "Wenn Sie dieses Bild löschen, werden diese Funktionen sofort zurückgesetzt.",
+        "unableToLoad": "Galerie kann nicht geladen werden",
         "downloadSelection": "Auswahl herunterladen",
         "currentlyInUse": "Dieses Bild wird derzeit in den folgenden Funktionen verwendet:",
         "deleteImagePermanent": "Gelöschte Bilder können nicht wiederhergestellt werden.",
@@ -173,12 +182,16 @@
         "gallery": "Galerie",
         "sortDirection": "Sortierreihenfolge",
         "sideBySide": "Nebeneinander",
+        "openViewer": "Viewer öffnen",
         "viewerImage": "Viewer-Bild",
         "exitCompare": "Vergleichen beenden",
+        "closeViewer": "Viewer schließen",
+        "selectAnImageToCompare": "Wählen Sie ein Bild zum Vergleichen",
         "stretchToFit": "Strecken bis es passt",
         "displayBoardSearch": "Board durchsuchen",
         "displaySearch": "Bild suchen",
         "go": "Los",
+        "jump": "Springen",
         "assetsTab": "Dateien, die Sie zur Verwendung in Ihren Projekten hochgeladen haben.",
         "imagesTab": "Bilder, die Sie in Invoke erstellt und gespeichert haben.",
         "boardsSettings": "Ordnereinstellungen",
@@ -561,6 +574,7 @@
         "urlOrLocalPath": "URL oder lokaler Pfad",
         "install": "Installieren",
         "textualInversions": "Textuelle Inversionen",
+        "ipAdapters": "IP-Adapter",
         "modelImageUpdated": "Modellbild aktualisiert",
         "path": "Pfad",
         "pathToConfig": "Pfad zur Konfiguration",
@@ -583,6 +597,7 @@
         "repoVariant": "Repo Variante",
         "learnMoreAboutSupportedModels": "Erfahren Sie mehr über die Modelle, die wir unterstützen",
         "clipEmbed": "CLIP einbetten",
+        "starterModelsInModelManager": "Modelle für Ihren Start finden Sie im Modell-Manager",
         "noModelsInstalledDesc1": "Installiere Modelle mit dem",
         "modelImageUpdateFailed": "Modellbild-Update fehlgeschlagen",
         "prune": "Bereinigen",
@@ -642,9 +657,11 @@
         "scaledHeight": "Skaliert H",
         "infillMethod": "Infill-Methode",
         "tileSize": "Kachelgröße",
+        "downloadImage": "Bild herunterladen",
         "usePrompt": "Prompt verwenden",
         "useSeed": "Seed verwenden",
         "useAll": "Alle verwenden",
+        "showOptionsPanel": "Optionsleiste zeigen",
         "copyImage": "Bild kopieren",
         "denoisingStrength": "Stärke der Entrauschung",
         "symmetry": "Symmetrie",
@@ -660,6 +677,10 @@
         "remixImage": "Remix des Bilds erstellen",
         "imageActions": "Weitere Bildaktionen",
         "invoke": {
+            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), Skalierte Bbox-Breite ist {{width}}",
+            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), Skalierte Bbox-Höhe ist {{height}}",
+            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), Bbox-Breite ist {{width}}",
+            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), Bbox-Höhe ist {{height}}",
             "noNodesInGraph": "Keine Knoten im Graphen",
             "canvasIsTransforming": "Leinwand ist beschäftigt (wird transformiert)",
             "canvasIsRasterizing": "Leinwand ist beschäftigt (wird gerastert)",
@@ -725,6 +746,7 @@
         "parametersNotSet": "Parameter nicht zurückgerufen",
         "addedToBoard": "Dem Board hinzugefügt",
         "loadedWithWarnings": "Workflow mit Warnungen geladen",
+        "imageSaved": "Bild gespeichert",
         "linkCopied": "Link kopiert",
         "problemCopyingLayer": "Ebene kann nicht kopiert werden",
         "problemSavingLayer": "Ebene kann nicht gespeichert werden",
@@ -735,6 +757,8 @@
         "prunedQueue": "Warteschlange bereinigt",
         "modelAddedSimple": "Modell zur Warteschlange hinzugefügt",
         "parametersSet": "Parameter zurückgerufen",
+        "imageNotLoadedDesc": "Bild konnte nicht gefunden werden",
+        "setControlImage": "Als Kontrollbild festlegen",
         "sentToUpscale": "An Vergrößerung gesendet",
         "parameterNotSetDescWithMessage": "{{parameter}} kann nicht zurückgerufen werden: {{message}}",
         "unableToLoadImageMetadata": "Bildmetadaten können nicht geladen werden",
@@ -747,6 +771,7 @@
         "parameterSet": "Parameter zurückgerufen",
         "importFailed": "Import fehlgeschlagen",
         "importSuccessful": "Import erfolgreich",
+        "setNodeField": "Als Knotenfeld festlegen",
         "somethingWentWrong": "Etwas ist schief gelaufen",
         "workflowLoaded": "Arbeitsablauf geladen",
         "workflowDeleted": "Arbeitsablauf gelöscht",
@@ -754,12 +779,16 @@
         "layerCopiedToClipboard": "Ebene in die Zwischenablage kopiert",
         "sentToCanvas": "An Leinwand gesendet",
         "problemDeletingWorkflow": "Problem beim Löschen des Arbeitsablaufs",
+        "uploadFailedInvalidUploadDesc_withCount_one": "Darf maximal 1 PNG-, JPEG- oder WEBP-Bild sein.",
+        "uploadFailedInvalidUploadDesc_withCount_other": "Dürfen maximal {{count}} PNG-, JPEG- oder WEBP-Bild sein.",
         "problemRetrievingWorkflow": "Problem beim Abrufen des Arbeitsablaufs",
         "uploadFailedInvalidUploadDesc": "Müssen PNG-, JPEG- oder WEBP-Bilder sein.",
         "pasteSuccess": "Eingefügt in {{destination}}",
         "pasteFailed": "Einfügen fehlgeschlagen",
         "unableToCopy": "Kopieren nicht möglich",
         "unableToCopyDesc_theseSteps": "diese Schritte",
+        "noRasterLayers": "Keine Rasterebenen gefunden",
+        "noActiveRasterLayers": "Keine aktiven Rasterebenen",
         "noVisibleRasterLayers": "Keine sichtbaren Rasterebenen"
     },
     "accessibility": {
@@ -812,13 +841,16 @@
         "archiveBoard": "Ordner archivieren",
         "archived": "Archiviert",
         "noBoards": "Kein {{boardType}} Ordner",
+        "hideBoards": "Ordner verstecken",
+        "viewBoards": "Ordner ansehen",
         "deletedPrivateBoardsCannotbeRestored": "Gelöschte Boards können nicht wiederhergestellt werden. Wenn Sie „Nur Board löschen“ wählen, werden die Bilder in einen privaten, nicht kategorisierten Status für den Ersteller des Bildes versetzt.",
         "assetsWithCount_one": "{{count}} in der Sammlung",
         "assetsWithCount_other": "{{count}} in der Sammlung",
         "deletedBoardsCannotbeRestored": "Gelöschte Ordner können nicht wiederhergestellt werden. Die Auswahl von \"Nur Ordner löschen\" verschiebt Bilder in einen unkategorisierten Zustand.",
         "updateBoardError": "Fehler beim Aktualisieren des Ordners",
         "uncategorizedImages": "Nicht kategorisierte Bilder",
-        "deleteAllUncategorizedImages": "Alle nicht kategorisierten Bilder löschen"
+        "deleteAllUncategorizedImages": "Alle nicht kategorisierten Bilder löschen",
+        "deletedImagesCannotBeRestored": "Gelöschte Bilder können nicht wiederhergestellt werden."
     },
     "queue": {
         "status": "Status",
@@ -873,6 +905,7 @@
         "batchQueuedDesc_other": "{{count}} Einträge an {{direction}} der Wartschlange hinzugefügt",
         "openQueue": "Warteschlange öffnen",
         "batchFailedToQueue": "Fehler beim Einreihen in die Stapelverarbeitung",
+        "batchFieldValues": "Stapelverarbeitungswerte",
         "batchQueued": "Stapelverarbeitung eingereiht",
         "graphQueued": "Graph eingereiht",
         "graphFailedToQueue": "Fehler beim Einreihen des Graphen",
@@ -919,6 +952,8 @@
         "allPrompts": "Alle Prompts",
         "imageDimensions": "Bilder Auslösungen",
         "parameterSet": "Parameter {{parameter}} setzen",
+        "recallParameter": "{{label}} Abrufen",
+        "parsingFailed": "Parsing Fehlgeschlagen",
         "canvasV2Metadata": "Leinwand",
         "guidance": "Führung",
         "seamlessXAxis": "Nahtlose X Achse",
@@ -1201,7 +1236,9 @@
         "collectionFieldType": "{{name}} (Sammlung)",
         "connectionWouldCreateCycle": "Verbindung würde einen Kreislauf/cycle schaffen",
         "inputMayOnlyHaveOneConnection": "Eingang darf nur eine Verbindung haben",
+        "hideLegendNodes": "Feldtyp-Legende ausblenden",
         "integer": "Ganze Zahl",
+        "addLinearView": "Zur linearen Ansicht hinzufügen",
         "currentImageDescription": "Zeigt das aktuelle Bild im Node-Editor an",
         "ipAdapter": "IP-Adapter",
         "hideMinimapnodes": "Miniatur-Kartenansicht ausblenden",
@@ -1210,6 +1247,7 @@
         "reloadNodeTemplates": "Knoten-Vorlagen neu laden",
         "newWorkflow": "Neuer Arbeitsablauf / Workflow",
         "newWorkflowDesc": "Einen neuen Arbeitsablauf erstellen?",
+        "noFieldsLinearview": "Keine Felder zur linearen Ansicht hinzugefügt",
         "clearWorkflow": "Workflow löschen",
         "clearWorkflowDesc": "Diesen Arbeitsablauf löschen und neu starten?",
         "noConnectionInProgress": "Es besteht keine Verbindung",
@@ -1217,6 +1255,7 @@
         "nodeVersion": "Knoten Version",
         "node": "Knoten",
         "nodeSearch": "Knoten suchen",
+        "removeLinearView": "Entfernen aus Linear View",
         "nodeOutputs": "Knoten-Ausgänge",
         "nodeTemplate": "Knoten-Vorlage",
         "nodeType": "Knotentyp",
@@ -1227,6 +1266,7 @@
         "clearWorkflowDesc2": "Ihr aktueller Arbeitsablauf hat ungespeicherte Änderungen.",
         "scheduler": "Planer",
         "showMinimapnodes": "MiniMap anzeigen",
+        "showLegendNodes": "Feldtyp-Legende anzeigen",
         "executionStateCompleted": "Erledigt",
         "downloadWorkflow": "Workflow JSON herunterladen",
         "executionStateInProgress": "In Bearbeitung",
@@ -1236,6 +1276,7 @@
         "fieldTypesMustMatch": "Feldtypen müssen übereinstimmen",
         "fitViewportNodes": "An Ansichtsgröße anpassen",
         "loadingNodes": "Lade Nodes...",
+        "mismatchedVersion": "Ungültiger Knoten: Knoten {{node}} vom Typ {{type}} hat keine passende Version (Update versuchen?)",
         "fullyContainNodesHelp": "Nodes müssen vollständig innerhalb der Auswahlbox sein, um ausgewählt werden zu können",
         "noWorkflow": "Kein Workflow",
         "executionStateError": "Fehler",
@@ -1247,7 +1288,9 @@
         "sourceNodeDoesNotExist": "Ungültiger Rand: Quell- / Ausgabe-Knoten {{node}} existiert nicht",
         "updateAllNodes": "Update Knoten",
         "allNodesUpdated": "Alle Knoten aktualisiert",
+        "unknownTemplate": "Unbekannte Vorlage",
         "updateApp": "Update App",
+        "unknownInput": "Unbekannte Eingabe: {{name}}",
         "unknownNodeType": "Unbekannter Knotentyp",
         "float": "Kommazahlen",
         "enum": "Aufzählung",
@@ -1263,6 +1306,7 @@
         "workflowAuthor": "Autor",
         "graph": "Graph",
         "workflowDescription": "Kurze Beschreibung",
+        "versionUnknown": " Version unbekannt",
         "workflow": "Arbeitsablauf",
         "noGraph": "Kein Graph",
         "version": "Version",
@@ -1280,6 +1324,7 @@
         "unknownErrorValidatingWorkflow": "Unbekannter Fehler beim Validieren des Arbeitsablaufes",
         "inputFieldTypeParseError": "Typ des Eingabefelds {{node}}.{{field}} kann nicht analysiert werden ({{message}})",
         "workflowSettings": "Arbeitsablauf Editor Einstellungen",
+        "unableToLoadWorkflow": "Arbeitsablauf kann nicht geladen werden",
         "viewMode": "In linearen Ansicht verwenden",
         "unableToValidateWorkflow": "Arbeitsablauf kann nicht validiert werden",
         "outputFieldTypeParseError": "Typ des Ausgabefelds {{node}}.{{field}} kann nicht analysiert werden ({{message}})",
@@ -1295,6 +1340,7 @@
         "arithmeticSequence": "Arithmetische Folge",
         "noBatchGroup": "keine Gruppe",
         "generatorNoValues": "leer",
+        "generatorLoading": "wird geladen",
         "generatorLoadFromFile": "Aus Datei laden",
         "showEdgeLabels": "Kantenbeschriftungen anzeigen",
         "downloadWorkflowError": "Fehler beim Herunterladen des Arbeitsablaufs",
@@ -1302,11 +1348,14 @@
         "description": "Beschreibung",
         "loadWorkflowDesc": "Arbeitsablauf laden?",
         "loadWorkflowDesc2": "Ihr aktueller Arbeitsablauf enthält nicht gespeicherte Änderungen.",
+        "loadingTemplates": "Lade {{name}}",
         "missingSourceOrTargetHandle": "Fehlender Quell- oder Zielgriff",
         "missingSourceOrTargetNode": "Fehlender Quell- oder Zielknoten",
         "showEdgeLabelsHelp": "Beschriftungen an Kanten anzeigen, um die verknüpften Knoten zu kennzeichnen"
     },
     "hrf": {
+        "enableHrf": "Korrektur für hohe Auflösungen",
+        "upscaleMethod": "Vergrößerungsmethode",
         "metadata": {
             "strength": "Auflösungs-Fix Stärke",
             "enabled": "Auflösungs-Fix aktiviert",
@@ -1317,9 +1366,11 @@
     "models": {
         "noMatchingModels": "Keine passenden Modelle",
         "loading": "lade",
+        "noMatchingLoRAs": "Keine passenden LoRAs",
         "noModelsAvailable": "Keine Modelle verfügbar",
         "selectModel": "Wählen ein Modell aus",
         "noRefinerModelsInstalled": "Keine SDXL Refiner-Modelle installiert",
+        "noLoRAsInstalled": "Keine LoRAs installiert",
         "addLora": "LoRA hinzufügen",
         "defaultVAE": "Standard VAE",
         "lora": "LoRA",
@@ -1349,23 +1400,31 @@
         "workflows": "Arbeitsabläufe",
         "workflowName": "Arbeitsablauf-Name",
         "saveWorkflowAs": "Arbeitsablauf speichern als",
+        "searchWorkflows": "Suche Arbeitsabläufe",
         "newWorkflowCreated": "Neuer Arbeitsablauf erstellt",
         "problemSavingWorkflow": "Problem beim Speichern des Arbeitsablaufs",
+        "problemLoading": "Problem beim Laden von Arbeitsabläufen",
         "downloadWorkflow": "Speichern als",
         "savingWorkflow": "Speichere Arbeitsablauf...",
         "saveWorkflow": "Arbeitsablauf speichern",
         "noWorkflows": "Keine Arbeitsabläufe",
         "workflowLibrary": "Bibliothek",
         "unnamedWorkflow": "Unbenannter Arbeitsablauf",
+        "noDescription": "Keine Beschreibung",
+        "clearWorkflowSearchFilter": "Suchfilter zurücksetzen",
         "workflowEditorMenu": "Arbeitsablauf-Editor Menü",
         "deleteWorkflow": "Arbeitsablauf löschen",
         "workflowSaved": "Arbeitsablauf gespeichert",
         "uploadWorkflow": "Aus Datei laden",
+        "openWorkflow": "Arbeitsablauf öffnen",
         "saveWorkflowToProject": "Arbeitsablauf in Projekt speichern",
         "workflowCleared": "Arbeitsablauf gelöscht",
         "loading": "Lade Arbeitsabläufe",
         "name": "Name",
         "ascending": "Aufsteigend",
+        "defaultWorkflows": "Standard Arbeitsabläufe",
+        "userWorkflows": "Benutzer Arbeitsabläufe",
+        "projectWorkflows": "Projekt Arbeitsabläufe",
         "opened": "Geöffnet",
         "loadWorkflow": "Arbeitsablauf $t(common.load)",
         "updated": "Aktualisiert",
@@ -1379,10 +1438,12 @@
         "copyShareLink": "Teilen-Link kopieren",
         "download": "Herunterladen",
         "convertGraph": "Graph konvertieren",
+        "filterByTags": "Nach Tags filtern",
         "yourWorkflows": "Ihre Arbeitsabläufe",
         "recentlyOpened": "Kürzlich geöffnet"
     },
     "sdxl": {
+        "concatPromptStyle": "Verknüpfen von Prompt & Stil",
         "scheduler": "Planer",
         "steps": "Schritte"
     },
@@ -1394,11 +1455,13 @@
         "addPromptTrigger": "Prompt-Trigger hinzufügen",
         "compatibleEmbeddings": "Kompatible Einbettungen",
         "replace": "Ersetzen",
+        "insert": "Einfügen",
         "discard": "Verwerfen",
         "generateFromImage": "Prompt aus Bild generieren",
         "expandCurrentPrompt": "Aktuelle Prompt erweitern",
         "uploadImageForPromptGeneration": "Bild zur Prompt-Generierung hochladen",
-        "expandingPrompt": "Prompt wird erweitert..."
+        "expandingPrompt": "Prompt wird erweitert...",
+        "resultTitle": "Prompt-Erweiterung abgeschlossen"
     },
     "ui": {
         "tabs": {
@@ -1537,6 +1600,8 @@
         "opacity": "Opazität",
         "removeBookmark": "Lesezeichen entfernen",
         "rasterLayer": "Rasterebene",
+        "rasterLayers_withCount_visible": "Rasterebenen ({{count}})",
+        "controlLayers_withCount_visible": "Kontroll-Ebenen ({{count}})",
         "deleteSelected": "Ausgewählte löschen",
         "newRegionalReferenceImageError": "Problem beim Erstellen eines regionalen Referenzbilds",
         "newControlLayerOk": "Kontroll-Ebene erstellt",
@@ -1544,8 +1609,10 @@
         "newRasterLayerOk": "Rasterebene erstellt",
         "moveToFront": "Nach vorne bringen",
         "copyToClipboard": "In die Zwischenablage kopieren",
+        "controlLayers_withCount_hidden": "Kontroll-Ebenen ({{count}} ausgeblendet)",
         "clearCaches": "Cache leeren",
         "controlLayer": "Kontroll-Ebene",
+        "rasterLayers_withCount_hidden": "Rasterebenen ({{count}} ausgeblendet)",
         "transparency": "Transparenz",
         "canvas": "Leinwand",
         "global": "Global",
@@ -1568,7 +1635,9 @@
         "weight": "Gewichtung",
         "addReferenceImage": "$t(controlLayers.referenceImage) hinzufügen",
         "addInpaintMask": "$t(controlLayers.inpaintMask) hinzufügen",
+        "addGlobalReferenceImage": "$t(controlLayers.globalReferenceImage) hinzufügen",
         "regionalGuidance": "Regionale Führung",
+        "globalReferenceImages_withCount_visible": "Globale Referenzbilder ({{count}})",
         "addPositivePrompt": "$t(controlLayers.prompt) hinzufügen",
         "locked": "Gesperrt",
         "showHUD": "HUD anzeigen",
@@ -1576,12 +1645,16 @@
         "addRasterLayer": "$t(controlLayers.rasterLayer) hinzufügen",
         "addRegionalGuidance": "$t(controlLayers.regionalGuidance) hinzufügen",
         "addControlLayer": "$t(controlLayers.controlLayer) hinzufügen",
+        "newCanvasSession": "Neue Leinwand-Sitzung",
         "replaceLayer": "Ebene ersetzen",
+        "newGallerySession": "Neue Galerie-Sitzung",
         "unlocked": "Entsperrt",
         "showProgressOnCanvas": "Fortschritt auf Leinwand anzeigen",
         "controlMode": {
             "balanced": "Ausgewogen"
         },
+        "globalReferenceImages_withCount_hidden": "Globale Referenzbilder ({{count}} ausgeblendet)",
+        "sendToGallery": "An Galerie senden",
         "stagingArea": {
             "accept": "Annehmen",
             "next": "Nächste",
@@ -1589,6 +1662,8 @@
             "discard": "Verwerfen",
             "previous": "Vorherige"
         },
+        "regionalGuidance_withCount_visible": "Regionale Führung ({{count}})",
+        "regionalGuidance_withCount_hidden": "Regionale Führung ({{count}} ausgeblendet)",
         "settings": {
             "snapToGrid": {
                 "on": "Ein",
@@ -1598,6 +1673,8 @@
         },
         "layer_one": "Ebene",
         "layer_other": "Ebenen",
+        "layer_withCount_one": "Ebene ({{count}})",
+        "layer_withCount_other": "Ebenen ({{count}})",
         "fill": {
             "fillStyle": "Füllstil",
             "diagonal": "Diagonal",

invokeai/frontend/web/public/locales/en.json

@@ -104,7 +104,6 @@
         "copy": "Copy",
         "copyError": "$t(gallery.copy) Error",
         "clipboard": "Clipboard",
-        "crop": "Crop",
         "on": "On",
         "off": "Off",
         "or": "or",
@@ -243,10 +242,7 @@
         "resultSubtitle": "Choose how to handle the expanded prompt:",
         "replace": "Replace",
         "insert": "Insert",
-        "discard": "Discard",
-        "noPromptHistory": "No prompt history recorded.",
-        "noMatchingPrompts": "No matching prompts in history.",
-        "toSwitchBetweenPrompts": "to switch between prompts."
+        "discard": "Discard"
     },
     "queue": {
         "queue": "Queue",
@@ -302,7 +298,7 @@
         "completedIn": "Completed in",
         "batch": "Batch",
         "origin": "Origin",
-        "destination": "Dest",
+        "destination": "Destination",
         "upscaling": "Upscaling",
         "canvas": "Canvas",
         "generation": "Generation",
@@ -328,13 +324,7 @@
         "iterations_other": "Iterations",
         "generations_one": "Generation",
         "generations_other": "Generations",
-        "batchSize": "Batch Size",
-        "createdAt": "Created At",
-        "completedAt": "Completed At",
-        "sortColumn": "Sort Column",
-        "sortBy": "Sort by {{column}}",
-        "sortOrderAscending": "Ascending",
-        "sortOrderDescending": "Descending"
+        "batchSize": "Batch Size"
     },
     "invocationCache": {
         "invocationCache": "Invocation Cache",
@@ -484,14 +474,6 @@
                 "title": "Focus Prompt",
                 "desc": "Move cursor focus to the positive prompt."
             },
-            "promptHistoryPrev": {
-                "title": "Previous Prompt in History",
-                "desc": "When the prompt is focused, move to the previous (older) prompt in your history."
-            },
-            "promptHistoryNext": {
-                "title": "Next Prompt in History",
-                "desc": "When the prompt is focused, move to the next (newer) prompt in your history."
-            },
             "toggleLeftPanel": {
                 "title": "Toggle Left Panel",
                 "desc": "Show or hide the left panel."
@@ -1270,7 +1252,6 @@
         "infillColorValue": "Fill Color",
         "info": "Info",
         "startingFrameImage": "Start Frame",
-        "startingFrameImageAspectRatioWarning": "Image aspect ratio does not match the video aspect ratio ({{videoAspectRatio}}). This could lead to unexpected cropping during video generation.",
         "invoke": {
             "addingImagesTo": "Adding images to",
             "modelDisabledForTrial": "Generating with {{modelName}} is not available on trial accounts. Visit your account settings to upgrade.",
@@ -2096,24 +2077,6 @@
         "pullBboxIntoLayerError": "Problem Pulling BBox Into Layer",
         "pullBboxIntoReferenceImageOk": "Bbox Pulled Into ReferenceImage",
         "pullBboxIntoReferenceImageError": "Problem Pulling BBox Into ReferenceImage",
-        "addAdjustments": "Add Adjustments",
-        "removeAdjustments": "Remove Adjustments",
-        "adjustments": {
-            "simple": "Simple",
-            "curves": "Curves",
-            "heading": "Adjustments",
-            "expand": "Expand adjustments",
-            "collapse": "Collapse adjustments",
-            "brightness": "Brightness",
-            "contrast": "Contrast",
-            "saturation": "Saturation",
-            "temperature": "Temperature",
-            "tint": "Tint",
-            "sharpness": "Sharpness",
-            "finish": "Finish",
-            "reset": "Reset",
-            "master": "Master"
-        },
         "regionIsEmpty": "Selected region is empty",
         "mergeVisible": "Merge Visible",
         "mergeDown": "Merge Down",
@@ -2485,21 +2448,12 @@
             "saveAs": "Save As",
             "cancel": "Cancel",
             "process": "Process",
-            "desc": "Select a single target object. After selection is complete, click <Bold>Apply</Bold> to discard everything outside the selected area, or save the selection as a new layer.",
-            "visualModeDesc": "Visual mode uses box and point inputs to select an object.",
-            "visualMode1": "Click and drag to draw a box around the object you want to select. You may get better results by drawing the box a bit larger or smaller than the object.",
-            "visualMode2": "Click to add a green <Bold>include</Bold> point, or shift-click to add a red <Bold>exclude</Bold> point to tell the model what to include or exclude.",
-            "visualMode3": "Points can be used to refine a box selection or used independently.",
-            "promptModeDesc": "Prompt mode uses text input to select an object.",
-            "promptMode1": "Type a brief description of the object you want to select.",
-            "promptMode2": "Use simple language, avoiding complex descriptions or multiple objects.",
+            "help1": "Select a single target object. Add <Bold>Include</Bold> and <Bold>Exclude</Bold> points to indicate which parts of the layer are part of the target object.",
+            "help2": "Start with one <Bold>Include</Bold> point within the target object. Add more points to refine the selection. Fewer points typically produce better results.",
+            "help3": "Invert the selection to select everything except the target object.",
             "clickToAdd": "Click on the layer to add a point",
             "dragToMove": "Drag a point to move it",
-            "clickToRemove": "Click on a point to remove it",
-            "model": "Model",
-            "segmentAnything1": "Segment Anything 1",
-            "segmentAnything2": "Segment Anything 2",
-            "prompt": "Selection Prompt"
+            "clickToRemove": "Click on a point to remove it"
         },
         "settings": {
             "snapToGrid": {
@@ -2794,9 +2748,8 @@
     "whatsNew": {
         "whatsNewInInvoke": "What's New in Invoke",
         "items": [
-            "Select Object v2: Improved object selection with point and box inputs or text prompts.",
-            "Raster Layer Adjustments: Easily adjust layer brightness, contrast, saturation, curves and more.",
-            "Prompt History: Review and quickly recall your last 100 prompts."
+            "Canvas: Color Picker does not sample alpha, bbox respects aspect ratio lock when resizing shuffle button for number fields in Workflow Builder, hide pixel dimension sliders when using a model that doesn't support them",
+            "Workflows: Add a Shuffle button to number input fields"
         ],
         "readReleaseNotes": "Read Release Notes",
         "watchRecentReleaseVideos": "Watch Recent Release Videos",

invokeai/frontend/web/public/locales/es.json

@@ -47,8 +47,11 @@
         "editor": "Editor",
         "orderBy": "Ordenar por",
         "file": "Archivo",
+        "goTo": "Ir a",
+        "imageFailedToLoad": "No se puede cargar la imagen",
         "saveAs": "Guardar Como",
         "somethingWentWrong": "Algo salió mal",
+        "nextPage": "Página Siguiente",
         "selected": "Seleccionado",
         "tab": "Tabulador",
         "positivePrompt": "Prompt Positivo",
@@ -58,6 +61,7 @@
         "unknown": "Desconocido",
         "input": "Entrada",
         "template": "Plantilla",
+        "prevPage": "Página Anterior",
         "red": "Rojo",
         "alpha": "Transparencia",
         "outputs": "Resultados",
@@ -90,6 +94,8 @@
         "edit": "Editar",
         "safetensors": "Safetensors",
         "toResolve": "Para resolver",
+        "localSystem": "Sistema local",
+        "notInstalled": "No $t(common.installed)",
         "outpaint": "outpaint",
         "simple": "Sencillo",
         "close": "Cerrar"
@@ -98,6 +104,7 @@
         "galleryImageSize": "Tamaño de la imagen",
         "gallerySettings": "Ajustes de la galería",
         "autoSwitchNewImages": "Auto seleccionar Imágenes nuevas",
+        "noImagesInGallery": "No hay imágenes para mostrar",
         "deleteImage_one": "Eliminar Imagen",
         "deleteImage_many": "Eliminar {{count}} Imágenes",
         "deleteImage_other": "Eliminar {{count}} Imágenes",
@@ -111,7 +118,9 @@
         "selectForCompare": "Seleccionar para comparar",
         "alwaysShowImageSizeBadge": "Mostrar siempre las dimensiones de la imagen",
         "currentlyInUse": "Esta imagen se utiliza actualmente con las siguientes funciones:",
+        "unableToLoad": "No se puede cargar la galería",
         "selectAllOnPage": "Seleccionar todo en la página",
+        "selectAnImageToCompare": "Seleccione una imagen para comparar",
         "bulkDownloadFailed": "Error en la descarga",
         "compareHelp2": "Presione <Kbd> M </Kbd> para recorrer los modos de comparación.",
         "move": "Mover",
@@ -136,6 +145,7 @@
         "exitBoardSearch": "Finalizar búsqueda",
         "exitSearch": "Salir de la búsqueda de imágenes",
         "featuresWillReset": "Si elimina esta imagen, dichas funciones se restablecerán inmediatamente.",
+        "jump": "Omitir",
         "loading": "Cargando",
         "newestFirst": "La más nueva primero",
         "unstarImage": "Dejar de ser favorita",
@@ -153,7 +163,9 @@
         "boardsSettings": "Ajustes de los tableros",
         "imagesSettings": "Configuración de imágenes de la galería",
         "compareHelp3": "Presione <Kbd> C </Kbd> para intercambiar las imágenes comparadas.",
-        "showArchivedBoards": "Mostrar paneles archivados"
+        "showArchivedBoards": "Mostrar paneles archivados",
+        "closeViewer": "Cerrar visor",
+        "openViewer": "Abrir visor"
     },
     "modelManager": {
         "modelManager": "Gestor de Modelos",
@@ -227,10 +239,12 @@
         "scaledHeight": "Alto escalado",
         "infillMethod": "Método de relleno",
         "tileSize": "Tamaño del mosaico",
+        "downloadImage": "Descargar imagen",
         "usePrompt": "Usar Entrada",
         "useSeed": "Usar Semilla",
         "useAll": "Usar Todo",
         "info": "Información",
+        "showOptionsPanel": "Mostrar panel lateral (O o T)",
         "symmetry": "Simetría",
         "copyImage": "Copiar la imagen",
         "general": "General",
@@ -309,6 +323,8 @@
         "hideMinimapnodes": "Ocultar el minimapa",
         "fitViewportNodes": "Ajustar la vista",
         "zoomOutNodes": "Alejar",
+        "hideLegendNodes": "Ocultar la leyenda del tipo de campo",
+        "showLegendNodes": "Mostrar la leyenda del tipo de campo",
         "showMinimapnodes": "Mostrar el minimapa",
         "reloadNodeTemplates": "Recargar las plantillas de nodos",
         "loadWorkflow": "Cargar el flujo de trabajo",
@@ -345,6 +361,7 @@
         "assetsWithCount_one": "{{count}} activo",
         "assetsWithCount_many": "{{count}} activos",
         "assetsWithCount_other": "{{count}} activos",
+        "hideBoards": "Ocultar paneles",
         "addPrivateBoard": "Agregar un panel privado",
         "addSharedBoard": "Añadir panel compartido",
         "boards": "Paneles",
@@ -355,6 +372,7 @@
         "noBoards": "No hay paneles {{boardType}}",
         "shared": "Paneles compartidos",
         "deletedPrivateBoardsCannotbeRestored": "Los paneles eliminados no se pueden restaurar. Al elegir \"Eliminar solo el panel\", las imágenes se colocan en un estado privado y sin categoría para el creador de la imagen.",
+        "viewBoards": "Ver paneles",
         "private": "Paneles privados",
         "updateBoardError": "No se pudo actualizar el panel"
     },
@@ -443,6 +461,7 @@
         "other": "Otro",
         "queueFront": "Añadir al principio de la cola",
         "gallery": "Galería",
+        "batchFieldValues": "Valores de procesamiento por lotes",
         "session": "Sesión",
         "notReady": "La cola aún no está lista",
         "graphQueued": "Gráfico en cola",
@@ -475,11 +494,15 @@
         "layer_one": "Capa",
         "layer_many": "Capas",
         "layer_other": "Capas",
+        "layer_withCount_one": "({{count}}) capa",
+        "layer_withCount_many": "({{count}}) capas",
+        "layer_withCount_other": "({{count}}) capas",
         "copyToClipboard": "Copiar al portapapeles"
     },
     "whatsNew": {
         "readReleaseNotes": "Leer las notas de la versión",
         "watchRecentReleaseVideos": "Ver videos de versiones recientes",
+        "watchUiUpdatesOverview": "Descripción general de las actualizaciones de la interfaz de usuario de Watch",
         "whatsNewInInvoke": "Novedades en Invoke",
         "items": [
             "<StrongComponent>SD 3.5</StrongComponent>: compatibilidad con SD 3.5 Medium y Large."
@@ -504,11 +527,13 @@
     },
     "hrf": {
         "hrf": "Solución de alta resolución",
+        "enableHrf": "Activar corrección de alta resolución",
         "metadata": {
             "enabled": "Corrección de alta resolución activada",
             "strength": "Forzar la corrección de alta resolución",
             "method": "Método de corrección de alta resolución"
-        }
+        },
+        "upscaleMethod": "Método de expansión"
     },
     "prompt": {
         "addPromptTrigger": "Añadir activador de los avisos",
@@ -839,8 +864,10 @@
         "seed": "Semilla",
         "strength": "Forzar imagen a imagen",
         "recallParameters": "Parámetros de recuperación",
+        "recallParameter": "Recuperar {{label}}",
         "steps": "Pasos",
-        "noRecallParameters": "Sin parámetros para recuperar"
+        "noRecallParameters": "Sin parámetros para recuperar",
+        "parsingFailed": "Error al analizar"
     },
     "system": {
         "logLevel": {

invokeai/frontend/web/public/locales/fi.json

@@ -28,6 +28,7 @@
     "gallery": {
         "galleryImageSize": "Kuvan koko",
         "gallerySettings": "Gallerian asetukset",
-        "autoSwitchNewImages": "Vaihda uusiin kuviin automaattisesti"
+        "autoSwitchNewImages": "Vaihda uusiin kuviin automaattisesti",
+        "noImagesInGallery": "Ei kuvia galleriassa"
     }
 }

invokeai/frontend/web/public/locales/fr.json

@@ -27,15 +27,21 @@
         "error": "Erreur",
         "installed": "Installé",
         "format": "format",
+        "goTo": "Aller à",
         "input": "Entrée",
         "linear": "Linéaire",
+        "localSystem": "Système local",
         "learnMore": "En savoir plus",
         "modelManager": "Gestionnaire de modèle",
+        "notInstalled": "Non $t(common.installed)",
         "openInNewTab": "Ouvrir dans un nouvel onglet",
         "somethingWentWrong": "Une erreur s'est produite",
         "created": "Créé",
         "tab": "Onglet",
         "folder": "Dossier",
+        "imageFailedToLoad": "Impossible de charger l'Image",
+        "prevPage": "Page précédente",
+        "nextPage": "Page suivante",
         "selected": "Sélectionné",
         "save": "Enregistrer",
         "updated": "Mis à jour",
@@ -105,6 +111,7 @@
         "min": "Min",
         "max": "Max",
         "values": "Valeurs",
+        "resetToDefaults": "Réinitialiser par défaut",
         "seed": "Graine",
         "combinatorial": "Combinatoire"
     },
@@ -112,9 +119,11 @@
         "galleryImageSize": "Taille de l'image",
         "gallerySettings": "Paramètres de la galerie",
         "autoSwitchNewImages": "Basculer automatiquement vers de nouvelles images",
+        "noImagesInGallery": "Aucune image à afficher",
         "bulkDownloadRequestedDesc": "Votre demande de téléchargement est en cours de traitement. Cela peut prendre quelques instants.",
         "deleteSelection": "Supprimer la sélection",
         "selectAllOnPage": "Séléctionner toute la page",
+        "unableToLoad": "Impossible de charger la Galerie",
         "featuresWillReset": "Si vous supprimez cette image, ces fonctionnalités vont être réinitialisés.",
         "loading": "Chargement",
         "sortDirection": "Direction de tri",
@@ -140,6 +149,7 @@
         "openInViewer": "Ouvrir dans le Visualiseur",
         "showArchivedBoards": "Montrer les Planches archivées",
         "selectForCompare": "Séléctionner pour comparaison",
+        "selectAnImageToCompare": "Séléctionner une Image à comparer",
         "exitCompare": "Sortir de la comparaison",
         "compareHelp2": "Appuyez sur <Kbd>M</Kbd> pour faire défiler les modes de comparaison.",
         "swapImages": "Échanger les Images",
@@ -147,7 +157,10 @@
         "compareHelp1": "Maintenir <Kbd>Alt</Kbd> lors du clic d'une image dans la galerie ou en utilisant les flèches du clavier pour changer l'Image à comparer.",
         "compareHelp3": "Appuyer sur <Kbd>C</Kbd> pour échanger les images à comparer.",
         "image": "image",
+        "openViewer": "Ouvrir le Visualisateur",
+        "closeViewer": "Fermer le Visualisateur",
         "currentlyInUse": "Cette image est actuellement utilisée dans ces fonctionalités :",
+        "jump": "Sauter",
         "starImage": "Marquer l'Image",
         "download": "Téléchargement",
         "deleteImage_one": "Supprimer l'Image",
@@ -234,6 +247,7 @@
         "metadata": "Métadonnées",
         "scanFolder": "Scanner le dossier",
         "inplaceInstallDesc": "Installez les modèles sans copier les fichiers. Lors de l'utilisation du modèle, il sera chargé depuis cet emplacement. Si cette option est désactivée, le(s) fichier(s) du modèle seront copiés dans le répertoire des modèles géré par Invoke lors de l'installation.",
+        "ipAdapters": "Adaptateurs IP",
         "installQueue": "File d'attente d'installation",
         "modelImageDeleteFailed": "Échec de la suppression de l'image du modèle",
         "modelName": "Nom du modèle",
@@ -274,6 +288,7 @@
         "scanFolderHelper": "Le dossier sera analysé de manière récursive à la recherche de modèles. Cela peut prendre quelques instants pour des dossiers très volumineux.",
         "clipEmbed": "Intégration CLIP",
         "spandrelImageToImage": "Image vers Image (Spandrel)",
+        "starterModelsInModelManager": "Les modèles de démarrage peuvent être trouvés dans le gestionnaire de modèles",
         "t5Encoder": "Encodeur T5",
         "learnMoreAboutSupportedModels": "En savoir plus sur les modèles que nous prenons en charge",
         "includesNModels": "Contient {{n}} modèles et leurs dépendances",
@@ -331,10 +346,12 @@
         "infillMethod": "Méthode de Remplissage",
         "tileSize": "Taille des Tuiles",
         "copyImage": "Copier Image",
+        "downloadImage": "Télécharger Image",
         "usePrompt": "Utiliser la suggestion",
         "useSeed": "Utiliser la graine",
         "useAll": "Tout utiliser",
         "info": "Info",
+        "showOptionsPanel": "Afficher le panneau latéral (O ou T)",
         "invoke": {
             "noPrompts": "Aucun prompts généré",
             "missingInputForField": "entrée manquante",
@@ -345,16 +362,21 @@
             "noModelSelected": "Aucun modèle sélectionné",
             "noNodesInGraph": "Aucun nœud dans le graphique",
             "systemDisconnected": "Système déconnecté",
+            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), la hauteur de la bounding box est {{height}}",
+            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), la hauteur de la bounding box est {{height}}",
             "noFLUXVAEModelSelected": "Aucun modèle VAE sélectionné pour la génération FLUX",
             "canvasIsTransforming": "La Toile est occupée (en transformation)",
             "canvasIsRasterizing": "La Toile est occupée (en rastérisation)",
             "noCLIPEmbedModelSelected": "Aucun modèle CLIP Embed sélectionné pour la génération FLUX",
             "canvasIsFiltering": "La Toile est occupée (en filtration)",
+            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), la largeur de la bounding box est {{width}}",
             "noT5EncoderModelSelected": "Aucun modèle T5 Encoder sélectionné pour la génération FLUX",
+            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), la largeur de la bounding box mise à l'échelle est {{width}}",
             "canvasIsCompositing": "La Toile est occupée (en composition)",
             "collectionTooFewItems": "trop peu d'éléments, minimum {{minItems}}",
             "collectionTooManyItems": "trop d'éléments, maximum {{maxItems}}",
             "canvasIsSelectingObject": "La toile est occupée (sélection d'objet)",
+            "emptyBatches": "lots vides",
             "batchNodeNotConnected": "Noeud de lots non connecté : {{label}}",
             "fluxModelMultipleControlLoRAs": "Vous ne pouvez utiliser qu'un seul Control LoRA à la fois",
             "collectionNumberLTMin": "{{value}} < {{minimum}} (incl. min)",
@@ -446,7 +468,9 @@
         "informationalPopoversDisabled": "Pop-ups d'information désactivés",
         "informationalPopoversDisabledDesc": "Les pop-ups d'information ont été désactivés. Activez-les dans les paramètres.",
         "confirmOnNewSession": "Confirmer lors d'une nouvelle session",
+        "modelDescriptionsDisabledDesc": "Les descriptions des modèles dans les menus déroulants ont été désactivées. Activez-les dans les paramètres.",
         "enableModelDescriptions": "Activer les descriptions de modèle dans les menus déroulants",
+        "modelDescriptionsDisabled": "Descriptions de modèle dans les menus déroulants désactivés",
         "showDetailedInvocationProgress": "Afficher les détails de progression"
     },
     "toast": {
@@ -462,14 +486,17 @@
         "addedToBoard": "Ajouté aux ressources de la planche {{name}}",
         "workflowLoaded": "Workflow chargé",
         "connected": "Connecté au serveur",
+        "setNodeField": "Définir comme champ de nœud",
         "imageUploadFailed": "Échec de l'importation de l'image",
         "loadedWithWarnings": "Workflow chargé avec des avertissements",
         "imageUploaded": "Image importée",
         "modelAddedSimple": "Modèle ajouté à la file d'attente",
+        "setControlImage": "Définir comme image de contrôle",
         "workflowDeleted": "Workflow supprimé",
         "baseModelChangedCleared_one": "Effacé ou désactivé {{count}} sous-modèle incompatible",
         "baseModelChangedCleared_many": "Effacé ou désactivé {{count}} sous-modèles incompatibles",
         "baseModelChangedCleared_other": "Effacé ou désactivé {{count}} sous-modèles incompatibles",
+        "invalidUpload": "Importation invalide",
         "problemDownloadingImage": "Impossible de télécharger l'image",
         "problemRetrievingWorkflow": "Problème de récupération du Workflow",
         "problemDeletingWorkflow": "Problème de suppression du Workflow",
@@ -483,10 +510,12 @@
         "errorCopied": "Erreur copiée",
         "parametersSet": "Paramètres rappelés",
         "somethingWentWrong": "Quelque chose a échoué",
+        "imageSaved": "Image enregistrée",
         "unableToLoadStylePreset": "Impossible de charger le préréglage de style",
         "stylePresetLoaded": "Préréglage de style chargé",
         "parameterNotSetDescWithMessage": "Impossible de rappeler {{parameter}} : {{message}}",
         "importFailed": "Importation échouée",
+        "imageSavingFailed": "Échec de l'enregistrement de l'image",
         "importSuccessful": "Importation réussie",
         "outOfMemoryError": "Erreur de mémoire insuffisante",
         "sessionRef": "Session : {{sessionId}}",
@@ -494,11 +523,16 @@
         "parameterSetDesc": "Rappelé {{parameter}}",
         "parameterNotSetDesc": "Impossible de rappeler {{parameter}}",
         "layerCopiedToClipboard": "Calque copié dans le presse-papiers",
+        "layerSavedToAssets": "Calque enregistré dans les ressources",
         "problemCopyingLayer": "Impossible de copier la couche",
         "baseModelChanged": "Modèle de base changé",
         "problemSavingLayer": "Impossible d'enregistrer la couche",
+        "imageNotLoadedDesc": "Image introuvable",
         "linkCopied": "Lien copié",
         "imagesWillBeAddedTo": "Les images Importées seront ajoutées au ressources de la Planche {{boardName}}.",
+        "uploadFailedInvalidUploadDesc_withCount_one": "Doit être au maximum une image PNG ou JPEG.",
+        "uploadFailedInvalidUploadDesc_withCount_many": "Doit être au maximum {{count}} images PNG ou JPEG.",
+        "uploadFailedInvalidUploadDesc_withCount_other": "Doit être au maximum {{count}} images PNG ou JPEG.",
         "addedToUncategorized": "Ajouté aux ressources de la planche $t(boards.uncategorized)",
         "pasteSuccess": "Collé à {{destination}}",
         "pasteFailed": "Échec du collage",
@@ -546,6 +580,8 @@
         "movingImagesToBoard_one": "Déplacer {{count}} image à cette planche :",
         "movingImagesToBoard_many": "Déplacer {{count}} images à cette planche :",
         "movingImagesToBoard_other": "Déplacer {{count}} image à cette planche :",
+        "viewBoards": "Voir les Planches",
+        "hideBoards": "Cacher les Planches",
         "noBoards": "Pas de Planches {{boardType}}",
         "shared": "Planches Partagées",
         "searchBoard": "Chercher les Planches...",
@@ -645,6 +681,7 @@
         "batchQueued": "Lot ajouté à la file d'attente",
         "gallery": "Galerie",
         "notReady": "Impossible d'ajouter à la file d'attente",
+        "batchFieldValues": "Valeurs Champ Lot",
         "front": "début",
         "graphQueued": "Graph ajouté à la file d'attente",
         "other": "Autre",
@@ -675,11 +712,13 @@
         "compatibleEmbeddings": "Embeddings Compatibles"
     },
     "hrf": {
+        "upscaleMethod": "Méthode d'Agrandissement",
         "metadata": {
             "enabled": "Correction Haute Résolution Activée",
             "strength": "Force de la Correction Haute Résolution",
             "method": "Méthode de la Correction Haute Résolution"
         },
+        "enableHrf": "Activer la Correction Haute Résolution",
         "hrf": "Correction Haute Résolution"
     },
     "invocationCache": {
@@ -1447,7 +1486,8 @@
         "showDynamicPrompts": "Afficher les Prompts dynamiques",
         "dynamicPrompts": "Prompts Dynamiques",
         "promptsPreview": "Prévisualisation des Prompts",
-        "loading": "Génération des Pompts Dynamiques..."
+        "loading": "Génération des Pompts Dynamiques...",
+        "promptsToGenerate": "Prompts à générer"
     },
     "metadata": {
         "positivePrompt": "Prompt Positif",
@@ -1475,12 +1515,18 @@
         "recallParameters": "Rappeler les paramètres",
         "imageDimensions": "Dimensions de l'image",
         "parameterSet": "Paramètre {{parameter}} défini",
+        "parsingFailed": "L'analyse a échoué",
+        "recallParameter": "Rappeler {{label}}",
         "canvasV2Metadata": "Toile",
         "guidance": "Guide",
         "seamlessXAxis": "Axe X sans bords",
         "seamlessYAxis": "Axe Y sans bords"
     },
     "sdxl": {
+        "freePromptStyle": "Écriture de Prompt manuelle",
+        "concatPromptStyle": "Lier Prompt & Style",
+        "negStylePrompt": "Style Prompt Négatif",
+        "posStylePrompt": "Style Prompt Positif",
         "refinerStart": "Démarrer le Refiner",
         "denoisingStrength": "Force de débruitage",
         "steps": "Étapes",
@@ -1497,6 +1543,8 @@
     "nodes": {
         "showMinimapnodes": "Afficher la MiniCarte",
         "fitViewportNodes": "Ajuster la Vue",
+        "hideLegendNodes": "Masquer la légende du type de champ",
+        "showLegendNodes": "Afficher la légende du type de champ",
         "hideMinimapnodes": "Masquer MiniCarte",
         "zoomOutNodes": "Dézoomer",
         "zoomInNodes": "Zoomer",
@@ -1520,7 +1568,9 @@
         "colorCodeEdges": "Code de couleur des connexions",
         "colorCodeEdgesHelp": "Code couleur des connexions en fonction de leurs champs connectés",
         "currentImage": "Image actuelle",
+        "noFieldsLinearview": "Aucun champ ajouté à la vue linéaire",
         "float": "Flottant",
+        "mismatchedVersion": "Nœud invalide : le nœud {{node}} de type {{type}} a une version incompatible (essayez de mettre à jour ?)",
         "missingTemplate": "Nœud invalide : le nœud {{node}} de type {{type}} modèle manquant (non installé ?)",
         "noWorkflow": "Pas de Workflow",
         "validateConnectionsHelp": "Prévenir la création de connexions invalides et l'invocation de graphes invalides",
@@ -1531,10 +1581,12 @@
         "scheduler": "Planificateur",
         "notes": "Notes",
         "notesDescription": "Ajouter des notes sur votre workflow",
+        "unableToLoadWorkflow": "Impossible de charger le Workflow",
         "addNode": "Ajouter un nœud",
         "problemSettingTitle": "Problème lors de définition du Titre",
         "connectionWouldCreateCycle": "La connexion créerait un cycle",
         "currentImageDescription": "Affiche l'image actuelle dans l'éditeur de nœuds",
+        "versionUnknown": " Version inconnue",
         "cannotConnectInputToInput": "Impossible de connecter l'entrée à l'entrée",
         "addNodeToolTip": "Ajouter un nœud (Shift+A, Espace)",
         "fullyContainNodesHelp": "Les nœuds doivent être entièrement à l'intérieur de la zone de sélection pour être sélectionnés",
@@ -1550,6 +1602,7 @@
         "nodeSearch": "Rechercher des nœuds",
         "collection": "Collection",
         "noOutputRecorded": "Aucun résultat enregistré",
+        "removeLinearView": "Retirer de la vue linéaire",
         "snapToGrid": "Aligner sur la grille",
         "workflow": "Workflow",
         "updateApp": "Mettre à jour l'application",
@@ -1558,6 +1611,7 @@
         "noConnectionInProgress": "Aucune connexion en cours",
         "nodeType": "Type de nœud",
         "workflowContact": "Contact",
+        "unknownTemplate": "Modèle inconnu",
         "unknownNode": "Nœud inconnu",
         "workflowVersion": "Version",
         "string": "Chaîne de caractères",
@@ -1571,6 +1625,7 @@
         "cannotDuplicateConnection": "Impossible de créer des connexions en double",
         "resetToDefaultValue": "Réinitialiser à la valeur par défaut",
         "unknownNodeType": "Type de nœud inconnu",
+        "unknownInput": "Entrée inconnue : {{name}}",
         "prototypeDesc": "Cette invocation est un prototype. Elle peut subir des modifications majeures lors des mises à jour de l'application et peut être supprimée à tout moment.",
         "nodePack": "Paquet de nœuds",
         "sourceNodeDoesNotExist": "Connexion invalide : le nœud source/de sortie {{node}} n'existe pas",
@@ -1585,6 +1640,7 @@
         "clearWorkflow": "Effacer le Workflow",
         "clearWorkflowDesc": "Effacer ce workflow et en commencer un nouveau ?",
         "unsupportedArrayItemType": "type d'élément de tableau non pris en charge \"{{type}}\"",
+        "addLinearView": "Ajouter à la vue linéaire",
         "collectionOrScalarFieldType": "{{name}} (Unique ou Collection)",
         "unableToExtractEnumOptions": "impossible d'extraire les options d'énumération",
         "unsupportedAnyOfLength": "trop de membres dans l'union ({{count}})",
@@ -1592,6 +1648,7 @@
         "viewMode": "Utiliser en vue linéaire",
         "collectionFieldType": "{{name}} (Collection)",
         "newWorkflow": "Nouveau Workflow",
+        "reorderLinearView": "Réorganiser la vue linéaire",
         "outputFieldTypeParseError": "Impossible d'analyser le type du champ de sortie {{node}}.{{field}} ({{message}})",
         "unsupportedMismatchedUnion": "type CollectionOrScalar non concordant avec les types de base {{firstType}} et {{secondType}}",
         "unableToParseFieldType": "impossible d'analyser le type de champ",
@@ -1625,9 +1682,13 @@
         "arithmeticSequence": "Séquence Arithmétique",
         "uniformRandomDistribution": "Distribution Aléatoire Uniforme",
         "noBatchGroup": "aucun groupe",
+        "generatorLoading": "chargement",
         "generatorLoadFromFile": "Charger depuis un Fichier",
         "dynamicPromptsRandom": "Prompts Dynamiques (Aléatoire)",
+        "integerRangeGenerator": "Générateur d'interval d'entiers",
+        "generateValues": "Générer Valeurs",
         "linearDistribution": "Distribution Linéaire",
+        "floatRangeGenerator": "Générateur d'interval de nombres décimaux",
         "generatorNRandomValues_one": "{{count}} valeur aléatoire",
         "generatorNRandomValues_many": "{{count}} valeurs aléatoires",
         "generatorNRandomValues_other": "{{count}} valeurs aléatoires",
@@ -1647,6 +1708,7 @@
         "generatorImagesCategory": "Catégorie",
         "generatorImagesFromBoard": "Images de la Planche",
         "missingSourceOrTargetHandle": "Manque de gestionnaire source ou cible",
+        "loadingTemplates": "Chargement de {{name}}",
         "loadWorkflowDesc2": "Votre workflow actuel contient des modifications non enregistrées.",
         "generatorImages_one": "{{count}} image",
         "generatorImages_many": "{{count}} images",
@@ -1657,8 +1719,10 @@
         "noModelsAvailable": "Aucun modèle disponible",
         "loading": "chargement",
         "selectModel": "Sélectionner un modèle",
+        "noMatchingLoRAs": "Aucun LoRA correspondant",
         "lora": "LoRA",
         "noRefinerModelsInstalled": "Aucun modèle SDXL Refiner installé",
+        "noLoRAsInstalled": "Aucun LoRA installé",
         "addLora": "Ajouter LoRA",
         "defaultVAE": "VAE par défaut",
         "concepts": "Concepts"
@@ -1666,8 +1730,11 @@
     "workflows": {
         "workflowLibrary": "Bibliothèque",
         "loading": "Chargement des Workflows",
+        "searchWorkflows": "Chercher des Workflows",
         "workflowCleared": "Workflow effacé",
+        "noDescription": "Aucune description",
         "deleteWorkflow": "Supprimer le Workflow",
+        "openWorkflow": "Ouvrir le Workflow",
         "uploadWorkflow": "Charger à partir d'un fichier",
         "workflowName": "Nom du Workflow",
         "unnamedWorkflow": "Workflow sans nom",
@@ -1680,6 +1747,8 @@
         "problemSavingWorkflow": "Problème de sauvegarde du Workflow",
         "workflowEditorMenu": "Menu de l'Éditeur de Workflow",
         "newWorkflowCreated": "Nouveau Workflow créé",
+        "clearWorkflowSearchFilter": "Réinitialiser le filtre de recherche de Workflow",
+        "problemLoading": "Problème de chargement des Workflows",
         "workflowSaved": "Workflow enregistré",
         "noWorkflows": "Pas de Workflows",
         "ascending": "Ascendant",
@@ -1692,6 +1761,9 @@
         "opened": "Ouvert",
         "name": "Nom",
         "autoLayout": "Mise en page automatique",
+        "defaultWorkflows": "Workflows par défaut",
+        "userWorkflows": "Workflows de l'utilisateur",
+        "projectWorkflows": "Workflows du projet",
         "copyShareLink": "Copier le lien de partage",
         "chooseWorkflowFromLibrary": "Choisir le Workflow dans la Bibliothèque",
         "edit": "Modifer",
@@ -1708,6 +1780,7 @@
             "multiLine": "Multi Ligne",
             "headingPlaceholder": "En-tête vide",
             "emptyRootPlaceholderEditMode": "Faites glisser un élément de formulaire ou un champ de nœud ici pour commencer.",
+            "emptyRootPlaceholderViewMode": "Cliquez sur Modifier pour commencer à créer un formulaire pour ce workflow.",
             "containerPlaceholder": "Conteneur Vide",
             "row": "Ligne",
             "column": "Colonne",
@@ -1721,8 +1794,10 @@
             "builder": "Constructeur de Formulaire",
             "resetAllNodeFields": "Réinitialiser tous les champs de nœud",
             "deleteAllElements": "Supprimer tous les éléments de formulaire",
+            "workflowBuilderAlphaWarning": "Le constructeur de workflow est actuellement en version alpha. Il peut y avoir des changements majeurs avant la version stable.",
             "showDescription": "Afficher la description"
-        }
+        },
+        "openLibrary": "Ouvrir la Bibliothèque"
     },
     "whatsNew": {
         "whatsNewInInvoke": "Quoi de neuf dans Invoke",
@@ -1731,7 +1806,8 @@
             "<StrongComponent>FLUX Guidage Régional (bêta)</StrongComponent> : Notre version bêta de FLUX Guidage Régional est en ligne pour le contrôle des prompt régionaux.",
             "Autres améliorations : mise en file d'attente par lots plus rapide, meilleur redimensionnement, sélecteur de couleurs amélioré et nœuds de métadonnées."
         ],
-        "readReleaseNotes": "Notes de version"
+        "readReleaseNotes": "Notes de version",
+        "watchUiUpdatesOverview": "Aperçu des mises à jour de l'interface utilisateur"
     },
     "ui": {
         "tabs": {
@@ -1748,6 +1824,7 @@
     },
     "controlLayers": {
         "newLayerFromImage": "Nouvelle couche à partir de l'image",
+        "sendToGalleryDesc": "Appuyer sur Invoker génère et enregistre une image unique dans votre galerie.",
         "sendToCanvas": "Envoyer vers la Toile",
         "globalReferenceImage": "Image de référence globale",
         "newCanvasFromImage": "Nouvelle Toile à partir de l'image",
@@ -1903,6 +1980,7 @@
         },
         "bookmark": "Marque-page pour Changement Rapide",
         "saveLayerToAssets": "Enregistrer la couche dans les ressources",
+        "stagingOnCanvas": "Mise en attente des images sur",
         "enableTransparencyEffect": "Activer l'effet de transparence",
         "hidingType": "Masquer {{type}}",
         "settings": {
@@ -1933,6 +2011,11 @@
         "disableAutoNegative": "Désactiver l'Auto Négatif",
         "addNegativePrompt": "Ajouter $t(controlLayers.negativePrompt)",
         "addRegionalGuidance": "Ajouter $t(controlLayers.regionalGuidance)",
+        "controlLayers_withCount_hidden": "Control Layers ({{count}} cachées)",
+        "rasterLayers_withCount_hidden": "Couche de Rastérisation ({{count}} cachées)",
+        "regionalGuidance_withCount_hidden": "Guidage Régional ({{count}} caché)",
+        "rasterLayers_withCount_visible": "Couche de Rastérisation ({{count}})",
+        "inpaintMasks_withCount_visible": "Masques de remplissage ({{count}})",
         "layer_one": "Couche",
         "layer_many": "Couches",
         "layer_other": "Couches",
@@ -1982,6 +2065,8 @@
             "next": "Suivant",
             "saveToGallery": "Enregistrer dans la galerie"
         },
+        "viewProgressOnCanvas": "Voir les progrès et les sorties de la scène sur la <Btn>Toile</Btn>.",
+        "sendToCanvasDesc": "Appuyer sur Invoker met en attente votre travail en cours sur la toile.",
         "mergeVisibleError": "Erreur lors de la fusion des calques visibles",
         "mergeVisibleOk": "Couches visibles fusionnées",
         "clearHistory": "Effacer l'historique",
@@ -1990,6 +2075,8 @@
         "duplicate": "Dupliquer",
         "enableAutoNegative": "Activer l'Auto Négatif",
         "showHUD": "Afficher HUD",
+        "sendToGallery": "Envoyer à la galerie",
+        "sendingToGallery": "Envoi des générations à la galerie",
         "disableTransparencyEffect": "Désactiver l'effet de transparence",
         "HUD": {
             "entityStatus": {
@@ -2006,11 +2093,16 @@
         "opacity": "Opacité",
         "savedToGalleryError": "Erreur lors de l'enregistrement dans la galerie",
         "addInpaintMask": "Ajouter $t(controlLayers.inpaintMask)",
+        "newCanvasSessionDesc": "Cela effacera la toile et tous les paramètres, sauf votre sélection de modèle. Les générations seront mises en attente sur la toile.",
         "canvas": "Toile",
         "savedToGalleryOk": "Enregistré dans la galerie",
         "addPositivePrompt": "Ajouter $t(controlLayers.prompt)",
         "showProgressOnCanvas": "Afficher la progression sur la Toile",
+        "newGallerySession": "Nouvelle session de galerie",
+        "newCanvasSession": "Nouvelle session de toile",
         "showingType": "Afficher {{type}}",
+        "viewProgressInViewer": "Voir les progrès et les résultats dans le <Btn>Visionneur d'images</Btn>.",
+        "deletePrompt": "Supprimer le prompt",
         "addControlLayer": "Ajouter $t(controlLayers.controlLayer)",
         "global": "Global",
         "newGlobalReferenceImageOk": "Image de référence globale créée",
@@ -2024,6 +2116,16 @@
         "newRasterLayerError": "Problème de création de couche de rastérisation",
         "negativePrompt": "Prompt négatif",
         "weight": "Poids",
+        "globalReferenceImages_withCount_hidden": "Images de référence globales ({{count}} cachées)",
+        "inpaintMasks_withCount_hidden": "Masques de remplissage ({{count}} cachés)",
+        "regionalGuidance_withCount_visible": "Guidage Régional ({{count}})",
+        "globalReferenceImage_withCount_one": "$t(controlLayers.globalReferenceImage)",
+        "globalReferenceImage_withCount_many": "Images de référence globales",
+        "globalReferenceImage_withCount_other": "Images de référence globales",
+        "layer_withCount_one": "Couche {{count}}",
+        "layer_withCount_many": "Couches {{count}}",
+        "layer_withCount_other": "Couches {{count}}",
+        "globalReferenceImages_withCount_visible": "Images de référence globales ({{count}})",
         "controlMode": {
             "controlMode": "Mode de contrôle",
             "balanced": "Équilibré",
@@ -2047,14 +2149,18 @@
         },
         "fitBboxToLayers": "Ajuster la bounding box aux calques",
         "regionIsEmpty": "La zone sélectionnée est vide",
+        "controlLayers_withCount_visible": "Couches de contrôle ({{count}})",
         "cropLayerToBbox": "Rogner la couche selon la bounding box",
+        "sendingToCanvas": "Mise en attente des Générations sur la Toile",
         "copyToClipboard": "Copier dans le presse-papiers",
         "regionalGuidance_withCount_one": "$t(controlLayers.regionalGuidance)",
         "regionalGuidance_withCount_many": "Guidage Régional",
         "regionalGuidance_withCount_other": "Guidage Régional",
+        "newGallerySessionDesc": "Cela effacera la toile et tous les paramètres, sauf votre sélection de modèle. Les générations seront envoyées à la galerie.",
         "inpaintMask_withCount_one": "$t(controlLayers.inpaintMask)",
         "inpaintMask_withCount_many": "Remplir les masques",
         "inpaintMask_withCount_other": "Remplir les masques",
+        "newImg2ImgCanvasFromImage": "Nouvelle Img2Img à partir de l'image",
         "bboxOverlay": "Afficher la superposition des Bounding Box",
         "moveToFront": "Déplacer vers le permier plan",
         "moveToBack": "Déplacer vers l'arrière plan",
@@ -2069,6 +2175,7 @@
         "inpaintMask": "Masque de remplissage",
         "deleteReferenceImage": "Supprimer l'image de référence",
         "addReferenceImage": "Ajouter $t(controlLayers.referenceImage)",
+        "addGlobalReferenceImage": "Ajouter $t(controlLayers.globalReferenceImage)",
         "removeBookmark": "Supprimer le marque-page",
         "regionalGuidance": "Guide régional",
         "regionalReferenceImage": "Image de référence régionale",
@@ -2097,12 +2204,16 @@
             "pointType": "Type de point",
             "exclude": "Exclure",
             "process": "Traiter",
-            "reset": "Réinitialiser"
+            "reset": "Réinitialiser",
+            "help1": "Sélectionnez un seul objet cible. Ajoutez des points <Bold>Inclure</Bold> et <Bold>Exclure</Bold> pour indiquer quelles parties de la couche font partie de l'objet cible.",
+            "help2": "Commencez par un point <Bold>Inclure</Bold> au sein de l'objet cible. Ajoutez d'autres points pour affiner la sélection. Moins de points produisent généralement de meilleurs résultats.",
+            "help3": "Inversez la sélection pour sélectionner tout sauf l'objet cible."
         },
         "convertRegionalGuidanceTo": "Convertir $t(controlLayers.regionalGuidance) vers",
         "copyRasterLayerTo": "Copier $t(controlLayers.rasterLayer) vers",
         "newControlLayer": "Nouveau $t(controlLayers.controlLayer)",
         "newRegionalGuidance": "Nouveau $t(controlLayers.regionalGuidance)",
+        "replaceCurrent": "Remplacer Actuel",
         "convertControlLayerTo": "Convertir $t(controlLayers.controlLayer) vers",
         "convertInpaintMaskTo": "Convertir $t(controlLayers.inpaintMask) vers",
         "copyControlLayerTo": "Copier $t(controlLayers.controlLayer) vers",
@@ -2148,7 +2259,9 @@
         "pasteToBboxDesc": "Nouvelle couche (dans Bbox)",
         "pasteToCanvasDesc": "Nouvelle couche (dans la Toile)",
         "useImage": "Utiliser l'image",
-        "referenceImageEmptyState": "<UploadButton>Séléctionner une image</UploadButton> ou faites glisser une image depuis la <GalleryButton>galerie</GalleryButton> sur cette couche pour commencer."
+        "pastedTo": "Collé à {{destination}}",
+        "referenceImageEmptyState": "<UploadButton>Séléctionner une image</UploadButton> ou faites glisser une image depuis la <GalleryButton>galerie</GalleryButton> sur cette couche pour commencer.",
+        "referenceImageGlobal": "Image de référence (Globale)"
     },
     "upscaling": {
         "exceedsMaxSizeDetails": "La limite maximale d'agrandissement est de {{maxUpscaleDimension}}x{{maxUpscaleDimension}} pixels. Veuillez essayer une image plus petite ou réduire votre sélection d'échelle.",

invokeai/frontend/web/public/locales/he.json

@@ -50,7 +50,8 @@
     "gallery": {
         "galleryImageSize": "גודל תמונה",
         "gallerySettings": "הגדרות גלריה",
-        "autoSwitchNewImages": "החלף אוטומטית לתמונות חדשות"
+        "autoSwitchNewImages": "החלף אוטומטית לתמונות חדשות",
+        "noImagesInGallery": "אין תמונות בגלריה"
     },
     "parameters": {
         "images": "תמונות",
@@ -69,10 +70,12 @@
         "tileSize": "גודל אריח",
         "symmetry": "סימטריה",
         "copyImage": "העתקת תמונה",
+        "downloadImage": "הורדת תמונה",
         "usePrompt": "שימוש בבקשה",
         "useSeed": "שימוש בזרע",
         "useAll": "שימוש בהכל",
         "info": "פרטים",
+        "showOptionsPanel": "הצג חלונית אפשרויות",
         "shuffle": "ערבוב",
         "noiseThreshold": "סף רעש",
         "perlinNoise": "רעש פרלין",

invokeai/frontend/web/public/locales/it.json

@@ -26,6 +26,7 @@
         "modelManager": "Gestione Modelli",
         "communityLabel": "Comunità",
         "advanced": "Avanzate",
+        "imageFailedToLoad": "Impossibile caricare l'immagine",
         "learnMore": "Per saperne di più",
         "ipAdapter": "Adattatore IP",
         "t2iAdapter": "Adattatore T2I",
@@ -44,18 +45,22 @@
         "somethingWentWrong": "Qualcosa è andato storto",
         "copyError": "Errore $t(gallery.copy)",
         "input": "Ingresso",
+        "notInstalled": "Non $t(common.installed)",
         "unknownError": "Errore sconosciuto",
         "updated": "Aggiornato",
         "save": "Salva",
         "created": "Creato",
+        "prevPage": "Pagina precedente",
         "delete": "Elimina",
         "orderBy": "Ordina per",
+        "nextPage": "Pagina successiva",
         "saveAs": "Salva come",
         "direction": "Direzione",
         "or": "o",
         "red": "Rosso",
         "aboutHeading": "Possiedi il tuo potere creativo",
         "aboutDesc": "Utilizzi Invoke per lavoro? Guarda qui:",
+        "localSystem": "Sistema locale",
         "green": "Verde",
         "blue": "Blu",
         "alpha": "Alfa",
@@ -71,6 +76,7 @@
         "positivePrompt": "Prompt positivo",
         "negativePrompt": "Prompt negativo",
         "selected": "Selezionato",
+        "goTo": "Vai a",
         "editor": "Editor",
         "tab": "Scheda",
         "enabled": "Abilitato",
@@ -96,6 +102,7 @@
         "values": "Valori",
         "start": "Inizio",
         "end": "Fine",
+        "resetToDefaults": "Ripristina le impostazioni predefinite",
         "seed": "Seme",
         "combinatorial": "Combinatorio",
         "count": "Quantità",
@@ -124,20 +131,13 @@
         "fullView": "Vista completa",
         "removeNegativePrompt": "Rimuovi prompt negativo",
         "addNegativePrompt": "Aggiungi prompt negativo",
-        "selectYourModel": "Seleziona il modello",
-        "goTo": "Vai a",
-        "imageFailedToLoad": "Impossibile caricare l'immagine",
-        "localSystem": "Sistema locale",
-        "notInstalled": "Non $t(common.installed)",
-        "prevPage": "Pagina precedente",
-        "nextPage": "Pagina successiva",
-        "resetToDefaults": "Ripristina impostazioni predefinite",
-        "crop": "Ritaglia"
+        "selectYourModel": "Seleziona il modello"
     },
     "gallery": {
         "galleryImageSize": "Dimensione dell'immagine",
         "gallerySettings": "Impostazioni della galleria",
         "autoSwitchNewImages": "Passaggio automatico a nuove immagini",
+        "noImagesInGallery": "Nessuna immagine da visualizzare",
         "deleteImage_one": "Elimina l'immagine",
         "deleteImage_many": "Elimina {{count}} immagini",
         "deleteImage_other": "Elimina {{count}} immagini",
@@ -145,6 +145,7 @@
         "autoAssignBoardOnClick": "Assegna automaticamente la bacheca al clic",
         "featuresWillReset": "Se elimini questa immagine, quelle funzionalità verranno immediatamente ripristinate.",
         "loading": "Caricamento in corso",
+        "unableToLoad": "Impossibile caricare la Galleria",
         "currentlyInUse": "Questa immagine è attualmente utilizzata nelle seguenti funzionalità:",
         "copy": "Copia",
         "download": "Scarica",
@@ -164,6 +165,7 @@
         "alwaysShowImageSizeBadge": "Mostra sempre le dimensioni dell'immagine",
         "openInViewer": "Apri nel visualizzatore",
         "selectForCompare": "Seleziona per il confronto",
+        "selectAnImageToCompare": "Seleziona un'immagine da confrontare",
         "slider": "Cursore",
         "sideBySide": "Fianco a Fianco",
         "compareImage": "Immagine di confronto",
@@ -188,8 +190,11 @@
         "exitBoardSearch": "Esci da Ricerca bacheca",
         "exitSearch": "Esci dalla ricerca immagini",
         "go": "Vai",
+        "jump": "Salta",
         "move": "Sposta",
         "gallery": "Galleria",
+        "openViewer": "Apri visualizzatore",
+        "closeViewer": "Chiudi visualizzatore",
         "imagesTab": "Immagini create e salvate in Invoke.",
         "assetsTab": "File che hai caricato per usarli nei tuoi progetti.",
         "boardsSettings": "Impostazioni Bacheche",
@@ -201,15 +206,9 @@
         "deleteVideo_many": "Elimina {{count}} video",
         "deleteVideo_other": "Elimina {{count}} video",
         "deleteVideoPermanent": "I video eliminati non possono essere ripristinati.",
-        "videos": "Video",
-        "videosTab": "Video creati e salvati in Invoke.",
-        "jump": "Salta",
         "noVideoSelected": "Nessun video selezionato",
-        "noImagesInGallery": "Nessuna immagine da visualizzare",
-        "unableToLoad": "Impossibile caricare la Galleria",
-        "selectAnImageToCompare": "Seleziona un'immagine da confrontare",
-        "openViewer": "Apri Visualizzatore",
-        "closeViewer": "Chiudi Visualizzatore"
+        "videos": "Video",
+        "videosTab": "Video creati e salvati in Invoke."
     },
     "hotkeys": {
         "searchHotkeys": "Cerca tasti di scelta rapida",
@@ -279,14 +278,6 @@
             "selectVideoTab": {
                 "title": "Seleziona la scheda Video",
                 "desc": "Seleziona la scheda Video."
-            },
-            "promptHistoryPrev": {
-                "title": "Prompt precedente nella cronologia",
-                "desc": "Quando il prompt è attivo, passa al prompt precedente (più vecchio) nella cronologia."
-            },
-            "promptHistoryNext": {
-                "title": "Prossimo prompt nella cronologia",
-                "desc": "Quando il prompt è attivo, passa al prompt successivo (più recente) nella cronologia."
             }
         },
         "hotkeys": "Tasti di scelta rapida",
@@ -437,14 +428,6 @@
             "toggleBbox": {
                 "title": "Attiva/disattiva la visibilità del riquadro di delimitazione",
                 "desc": "Nascondi o mostra il riquadro di delimitazione della generazione"
-            },
-            "setFillColorsToDefault": {
-                "title": "Imposta i colori come predefiniti",
-                "desc": "Imposta i colori degli strumenti correnti sui valori predefiniti."
-            },
-            "toggleFillColor": {
-                "title": "Attiva/disattiva colore di riempimento",
-                "desc": "Attiva/disattiva il colore di riempimento dello strumento corrente."
             }
         },
         "workflows": {
@@ -682,7 +665,9 @@
         "noModelsInstalled": "Nessun modello installato",
         "main": "Principali",
         "noModelsInstalledDesc1": "Installa i modelli con",
+        "ipAdapters": "Adattatori IP",
         "noMatchingModels": "Nessun modello corrispondente",
+        "starterModelsInModelManager": "I modelli iniziali possono essere trovati in Gestione Modelli",
         "spandrelImageToImage": "Immagine a immagine (Spandrel)",
         "learnMoreAboutSupportedModels": "Scopri di più sui modelli che supportiamo",
         "starterBundles": "Pacchetti per iniziare",
@@ -721,11 +706,13 @@
         "urlForbiddenErrorMessage": "Potrebbe essere necessario richiedere l'autorizzazione al sito che distribuisce il modello.",
         "urlUnauthorizedErrorMessage": "Potrebbe essere necessario configurare un gettone API per accedere a questo modello.",
         "fileSize": "Dimensione del file",
+        "filterModels": "Filtra i modelli",
         "modelPickerFallbackNoModelsInstalled": "Nessun modello installato.",
         "modelPickerFallbackNoModelsInstalled2": "Visita <LinkComponent>Gestione modelli</LinkComponent> per installare i modelli.",
         "manageModels": "Gestione modelli",
         "hfTokenReset": "Ripristino del gettone HF",
         "relatedModels": "Modelli correlati",
+        "showOnlyRelatedModels": "Correlati",
         "installedModelsCount": "{{installed}} di {{total}} modelli installati.",
         "allNModelsInstalled": "Tutti i {{count}} modelli installati",
         "nToInstall": "{{count}} da installare",
@@ -741,18 +728,14 @@
             "recommendedModels": "Modelli consigliati",
             "exploreStarter": "Oppure sfoglia tutti i modelli iniziali disponibili",
             "welcome": "Benvenuti in Gestione Modelli",
-            "bundleDescription": "Ogni pacchetto include modelli essenziali per ogni famiglia di modelli e modelli base selezionati per iniziare.",
             "quickStart": "Pacchetti di avvio rapido",
-            "browseAll": "Oppure sfoglia tutti i modelli disponibili:"
+            "bundleDescription": "Ogni pacchetto include modelli essenziali per ogni famiglia di modelli e modelli base selezionati per iniziare.",
+            "browseAll": "Oppure scopri tutti i modelli disponibili:"
         },
         "launchpadTab": "Rampa di lancio",
         "installBundle": "Installa pacchetto",
         "installBundleMsg1": "Vuoi davvero installare il pacchetto {{bundleName}}?",
-        "installBundleMsg2": "Questo pacchetto installerà i seguenti {{count}} modelli:",
-        "filterModels": "Filtra i modelli",
-        "ipAdapters": "Adattatori IP",
-        "showOnlyRelatedModels": "Correlati",
-        "starterModelsInModelManager": "I modelli di avvio possono essere trovati in Gestione Modelli"
+        "installBundleMsg2": "Questo pacchetto installerà i seguenti {{count}} modelli:"
     },
     "parameters": {
         "images": "Immagini",
@@ -774,10 +757,12 @@
         "scaledHeight": "Altezza scalata",
         "infillMethod": "Metodo di riempimento",
         "tileSize": "Dimensione piastrella",
+        "downloadImage": "Scarica l'immagine",
         "usePrompt": "Usa Prompt",
         "useSeed": "Usa Seme",
         "useAll": "Usa Tutto",
         "info": "Informazioni",
+        "showOptionsPanel": "Mostra il pannello laterale (O o T)",
         "general": "Generale",
         "denoisingStrength": "Forza di riduzione del rumore",
         "copyImage": "Copia immagine",
@@ -804,6 +789,10 @@
             "missingNodeTemplate": "Modello di nodo mancante",
             "missingInputForField": "ingresso mancante",
             "missingFieldTemplate": "Modello di campo mancante",
+            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), altezza riquadro è {{height}}",
+            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), larghezza riquadro è {{width}}",
+            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), larghezza del riquadro scalato è {{width}}",
+            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), altezza del riquadro scalato è {{height}}",
             "noT5EncoderModelSelected": "Nessun modello di encoder T5 selezionato per la generazione con FLUX",
             "noCLIPEmbedModelSelected": "Nessun modello CLIP Embed selezionato per la generazione con FLUX",
             "noFLUXVAEModelSelected": "Nessun modello VAE selezionato per la generazione con FLUX",
@@ -819,6 +808,7 @@
             "collectionStringTooLong": "troppo lungo, massimo {{maxLength}}",
             "batchNodeNotConnected": "Nodo Lotto non connesso: {{label}}",
             "batchNodeEmptyCollection": "Alcuni nodi lotto hanno raccolte vuote",
+            "emptyBatches": "lotti vuoti",
             "batchNodeCollectionSizeMismatch": "Le dimensioni della raccolta nel Lotto {{batchGroupId}} non corrispondono",
             "collectionStringTooShort": "troppo corto, minimo {{minLength}}",
             "collectionNumberNotMultipleOf": "{{value}} non è multiplo di {{multipleOf}}",
@@ -836,12 +826,7 @@
             "promptExpansionPending": "Espansione del prompt in corso",
             "noStartingFrameImage": "Nessuna immagine del fotogramma iniziale",
             "videoIsDisabled": "La generazione di video non è abilitata per gli account {{accountType}}.",
-            "incompatibleLoRAs": "Aggiunti LoRA incompatibili",
-            "emptyBatches": "lotti vuoti",
-            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), la larghezza del riquadro è {{width}}",
-            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), l'altezza del riquadro è {{height}}",
-            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), la larghezza ridimensionata del riquadro è {{width}}",
-            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), l'altezza ridimensionata del riquadro è {{height}}"
+            "incompatibleLoRAs": "Aggiunti LoRA incompatibili"
         },
         "useCpuNoise": "Usa la CPU per generare rumore",
         "iterations": "Iterazioni",
@@ -882,10 +867,7 @@
         "videoActions": "Azioni video",
         "sendToVideo": "Invia al Video",
         "video": "Video",
-        "resolution": "Risoluzione",
-        "downloadImage": "Scarica l'immagine",
-        "showOptionsPanel": "Mostra pannello laterale (O o T)",
-        "startingFrameImageAspectRatioWarning": "Le proporzioni dell'immagine non corrispondono alle proporzioni del video ({{videoAspectRatio}}). Ciò potrebbe causare ritagli imprevisti durante la generazione del video."
+        "resolution": "Risoluzione"
     },
     "settings": {
         "models": "Modelli",
@@ -922,10 +904,10 @@
         "informationalPopoversDisabledDesc": "I testi informativi a comparsa sono disabilitati. Attivali nelle impostazioni.",
         "confirmOnNewSession": "Conferma su nuova sessione",
         "enableModelDescriptions": "Abilita le descrizioni dei modelli nei menu a discesa",
-        "showDetailedInvocationProgress": "Mostra dettagli avanzamento",
-        "enableHighlightFocusedRegions": "Evidenzia le regioni interessate",
         "modelDescriptionsDisabled": "Descrizioni dei modelli nei menu a discesa disabilitate",
-        "modelDescriptionsDisabledDesc": "Le descrizioni dei modelli nei menu a discesa sono state disattivate. Abilitale nelle Impostazioni."
+        "modelDescriptionsDisabledDesc": "Le descrizioni dei modelli nei menu a discesa sono state disabilitate. Abilitale nelle Impostazioni.",
+        "showDetailedInvocationProgress": "Mostra dettagli avanzamento",
+        "enableHighlightFocusedRegions": "Evidenzia le regioni interessate"
     },
     "toast": {
         "uploadFailed": "Caricamento fallito",
@@ -946,7 +928,10 @@
         "addedToBoard": "Aggiunto alle risorse della bacheca {{name}}",
         "modelAddedSimple": "Modello aggiunto alla Coda",
         "imageUploadFailed": "Caricamento immagine non riuscito",
+        "setControlImage": "Imposta come immagine di controllo",
+        "setNodeField": "Imposta come campo nodo",
         "workflowLoaded": "Flusso di lavoro caricato",
+        "invalidUpload": "Caricamento non valido",
         "problemDeletingWorkflow": "Problema durante l'eliminazione del flusso di lavoro",
         "workflowDeleted": "Flusso di lavoro eliminato",
         "problemRetrievingWorkflow": "Problema nel recupero del flusso di lavoro",
@@ -966,6 +951,7 @@
         "outOfMemoryErrorDesc": "Le impostazioni della generazione attuale superano la capacità del sistema. Modifica le impostazioni e riprova.",
         "importFailed": "Importazione non riuscita",
         "importSuccessful": "Importazione riuscita",
+        "layerSavedToAssets": "Livello salvato nelle risorse",
         "problemSavingLayer": "Impossibile salvare il livello",
         "unableToLoadImage": "Impossibile caricare l'immagine",
         "problemCopyingLayer": "Impossibile copiare il livello",
@@ -974,10 +960,16 @@
         "unableToLoadStylePreset": "Impossibile caricare lo stile predefinito",
         "stylePresetLoaded": "Stile predefinito caricato",
         "unableToLoadImageMetadata": "Impossibile caricare i metadati dell'immagine",
+        "imageSaved": "Immagine salvata",
+        "imageSavingFailed": "Salvataggio dell'immagine non riuscito",
         "layerCopiedToClipboard": "Livello copiato negli appunti",
+        "imageNotLoadedDesc": "Impossibile trovare l'immagine",
         "linkCopied": "Collegamento copiato",
         "addedToUncategorized": "Aggiunto alle risorse della bacheca $t(boards.uncategorized)",
         "imagesWillBeAddedTo": "Le immagini caricate verranno aggiunte alle risorse della bacheca {{boardName}}.",
+        "uploadFailedInvalidUploadDesc_withCount_one": "Devi caricare al massimo 1 immagine PNG, JPEG o WEBP.",
+        "uploadFailedInvalidUploadDesc_withCount_many": "Devi caricare al massimo {{count}} immagini PNG, JPEG o WEBP.",
+        "uploadFailedInvalidUploadDesc_withCount_other": "Devi caricare al massimo {{count}} immagini PNG, JPEG o WEBP.",
         "outOfMemoryErrorDescLocal": "Segui la nostra <LinkComponent>guida per bassa VRAM</LinkComponent> per ridurre gli OOM.",
         "pasteFailed": "Incolla non riuscita",
         "pasteSuccess": "Incollato su {{destination}}",
@@ -990,43 +982,33 @@
         "workflowUnpublished": "Flusso di lavoro non pubblicato",
         "chatGPT4oIncompatibleGenerationMode": "ChatGPT 4o supporta solo la conversione da testo a immagine e da immagine a immagine. Utilizza altri modelli per le attività di Inpainting e Outpainting.",
         "imagenIncompatibleGenerationMode": "Google {{model}} supporta solo la generazione da testo a immagine. Utilizza altri modelli per le attività di conversione da immagine a immagine, inpainting e outpainting.",
+        "noRasterLayers": "Nessun livello raster trovato",
+        "noRasterLayersDesc": "Crea almeno un livello raster da esportare in PSD",
+        "noActiveRasterLayers": "Nessun livello raster attivo",
+        "noActiveRasterLayersDesc": "Abilitare almeno un livello raster da esportare in PSD",
         "noVisibleRasterLayers": "Nessun livello raster visibile",
         "noVisibleRasterLayersDesc": "Abilitare almeno un livello raster da esportare in PSD",
         "invalidCanvasDimensions": "Dimensioni della tela non valide",
         "canvasTooLarge": "Tela troppo grande",
         "canvasTooLargeDesc": "Le dimensioni della tela superano le dimensioni massime consentite per l'esportazione in formato PSD. Riduci la larghezza e l'altezza totali della tela e riprova.",
+        "failedToProcessLayers": "Impossibile elaborare i livelli",
         "psdExportSuccess": "Esportazione PSD completata",
         "psdExportSuccessDesc": "Esportazione riuscita di {{count}} livelli nel file PSD",
         "problemExportingPSD": "Problema durante l'esportazione PSD",
+        "noValidLayerAdapters": "Nessun adattatore di livello valido trovato",
         "fluxKontextIncompatibleGenerationMode": "FLUX Kontext non supporta la generazione di immagini posizionate sulla tela. Riprova utilizzando la sezione Immagine di riferimento e disattiva tutti i livelli raster.",
         "canvasManagerNotAvailable": "Gestione tela non disponibile",
         "promptExpansionFailed": "Abbiamo riscontrato un problema. Riprova a eseguire l'espansione del prompt.",
         "uploadAndPromptGenerationFailed": "Impossibile caricare l'immagine e generare il prompt",
         "promptGenerationStarted": "Generazione del prompt avviata",
+        "invalidBboxDesc": "Il riquadro di delimitazione non ha dimensioni valide",
+        "invalidBbox": "Riquadro di delimitazione non valido",
+        "noInpaintMaskSelectedDesc": "Seleziona una maschera di inpaint da invertire",
+        "noInpaintMaskSelected": "Nessuna maschera di inpaint selezionata",
         "noVisibleMasksDesc": "Crea o abilita almeno una maschera inpaint da invertire",
         "noVisibleMasks": "Nessuna maschera visibile",
         "maskInvertFailed": "Impossibile invertire la maschera",
-        "maskInverted": "Maschera invertita",
-        "uploadFailedInvalidUploadDesc_withCount_one": "Deve essere presente al massimo 1 immagine PNG, JPEG o WEBP.",
-        "uploadFailedInvalidUploadDesc_withCount_many": "Devono essere presenti al massimo {{count}} immagini PNG, JPEG o WEBP.",
-        "uploadFailedInvalidUploadDesc_withCount_other": "Devono essere presenti al massimo {{count}} immagini PNG, JPEG o WEBP.",
-        "imageNotLoadedDesc": "Impossibile trovare l'immagine",
-        "imageSaved": "Immagine salvata",
-        "imageSavingFailed": "Salvataggio dell'immagine non riuscito",
-        "invalidUpload": "Caricamento non valido",
-        "layerSavedToAssets": "Livello salvato nelle risorse",
-        "noRasterLayers": "Nessun livello raster trovato",
-        "noRasterLayersDesc": "Crea almeno un livello raster da esportare in PSD",
-        "noActiveRasterLayers": "Nessun livello raster attivo",
-        "noActiveRasterLayersDesc": "Abilita almeno un livello raster da esportare in PSD",
-        "failedToProcessLayers": "Impossibile elaborare i livelli",
-        "noValidLayerAdapters": "Nessun adattatore di livello valido trovato",
-        "setControlImage": "Imposta come immagine di controllo",
-        "setNodeField": "Imposta come campo nodo",
-        "noInpaintMaskSelected": "Nessuna maschera di inpaint selezionata",
-        "noInpaintMaskSelectedDesc": "Seleziona una maschera di inpaint da invertire",
-        "invalidBbox": "Riquadro di delimitazione non valido",
-        "invalidBboxDesc": "Il riquadro di delimitazione non ha dimensioni valide"
+        "maskInverted": "Maschera invertita"
     },
     "accessibility": {
         "invokeProgressBar": "Barra di avanzamento generazione",
@@ -1046,6 +1028,8 @@
     },
     "nodes": {
         "zoomOutNodes": "Rimpicciolire",
+        "hideLegendNodes": "Nascondi la legenda del tipo di campo",
+        "showLegendNodes": "Mostra legenda del tipo di campo",
         "hideMinimapnodes": "Nascondi minimappa",
         "showMinimapnodes": "Mostra minimappa",
         "zoomInNodes": "Ingrandire",
@@ -1071,22 +1055,27 @@
         "workflowSettings": "Impostazioni Editor del flusso di lavoro",
         "colorCodeEdges": "Bordi con codice colore",
         "noOutputRecorded": "Nessun output registrato",
+        "noFieldsLinearview": "Nessun campo aggiunto alla vista lineare",
+        "removeLinearView": "Rimuovi dalla vista lineare",
         "workflowDescription": "Breve descrizione",
         "workflowContact": "Contatto",
         "workflowVersion": "Versione",
         "workflow": "Flusso di lavoro",
         "noWorkflow": "Nessun flusso di lavoro",
-        "workflowTags": "Etichette",
+        "workflowTags": "Tag",
         "workflowValidation": "Errore di convalida del flusso di lavoro",
         "workflowAuthor": "Autore",
         "workflowName": "Nome",
         "workflowNotes": "Note",
+        "versionUnknown": " Versione sconosciuta",
         "unableToValidateWorkflow": "Impossibile convalidare il flusso di lavoro",
         "updateApp": "Aggiorna Applicazione",
+        "unableToLoadWorkflow": "Impossibile caricare il flusso di lavoro",
         "updateNode": "Aggiorna nodo",
         "version": "Versione",
         "notes": "Note",
         "problemSettingTitle": "Problema nell'impostazione del titolo",
+        "unknownTemplate": "Modello sconosciuto",
         "nodeType": "Tipo di nodo",
         "notesDescription": "Aggiunge note sul tuo flusso di lavoro",
         "unknownField": "Campo sconosciuto",
@@ -1105,9 +1094,10 @@
         "cannotConnectInputToInput": "Impossibile collegare ingresso a ingresso",
         "cannotConnectOutputToOutput": "Impossibile collegare uscita ad uscita",
         "cannotConnectToSelf": "Impossibile connettersi a se stesso",
+        "mismatchedVersion": "Nodo non valido: il nodo {{node}} di tipo {{type}} ha una versione non corrispondente (provare ad aggiornare?)",
         "loadingNodes": "Caricamento nodi...",
         "enum": "Enumeratore",
-        "float": "Decimale",
+        "float": "In virgola mobile",
         "currentImageDescription": "Visualizza l'immagine corrente nell'editor dei nodi",
         "fieldTypesMustMatch": "I tipi di campo devono corrispondere",
         "edge": "Collegamento",
@@ -1121,6 +1111,7 @@
         "unableToUpdateNodes_one": "Impossibile aggiornare {{count}} nodo",
         "unableToUpdateNodes_many": "Impossibile aggiornare {{count}} nodi",
         "unableToUpdateNodes_other": "Impossibile aggiornare {{count}} nodi",
+        "addLinearView": "Aggiungi alla vista Lineare",
         "unknownErrorValidatingWorkflow": "Errore sconosciuto durante la convalida del flusso di lavoro",
         "collectionFieldType": "{{name}} (Raccolta)",
         "collectionOrScalarFieldType": "{{name}} (Singola o Raccolta)",
@@ -1142,6 +1133,7 @@
         "targetNodeDoesNotExist": "Connessione non valida: il nodo di destinazione/input {{node}} non esiste",
         "unknownFieldType": "$t(nodes.unknownField) tipo: {{type}}",
         "deletedInvalidEdge": "Eliminata connessione non valida {{source}} -> {{target}}",
+        "unknownInput": "Input sconosciuto: {{name}}",
         "prototypeDesc": "Questa invocazione è un prototipo. Potrebbe subire modifiche sostanziali durante gli aggiornamenti dell'app e potrebbe essere rimossa in qualsiasi momento.",
         "betaDesc": "Questa invocazione è in versione beta. Fino a quando non sarà stabile, potrebbe subire modifiche importanti durante gli aggiornamenti dell'app. Abbiamo intenzione di supportare questa invocazione a lungo termine.",
         "newWorkflow": "Nuovo flusso di lavoro",
@@ -1152,6 +1144,7 @@
         "clearWorkflow": "Cancella il flusso di lavoro",
         "clearWorkflowDesc2": "Il tuo flusso di lavoro attuale presenta modifiche non salvate.",
         "viewMode": "Usa la vista lineare",
+        "reorderLinearView": "Riordina la vista lineare",
         "editMode": "Modifica nell'editor del flusso di lavoro",
         "resetToDefaultValue": "Ripristina il valore predefinito",
         "noFieldsViewMode": "Questo flusso di lavoro non ha campi selezionati da visualizzare. Visualizza il flusso di lavoro completo per configurare i valori.",
@@ -1175,14 +1168,18 @@
         "specialDesc": "Questa invocazione comporta una gestione speciale nell'applicazione. Ad esempio, i nodi Lotto vengono utilizzati per mettere in coda più grafici da un singolo flusso di lavoro.",
         "internalDesc": "Questa invocazione è utilizzata internamente da Invoke. Potrebbe subire modifiche significative durante gli aggiornamenti dell'app e potrebbe essere rimossa in qualsiasi momento.",
         "addItem": "Aggiungi elemento",
+        "generateValues": "Genera valori",
         "generatorNoValues": "vuoto",
         "linearDistribution": "Distribuzione lineare",
         "parseString": "Analizza stringa",
         "splitOn": "Diviso su",
         "noBatchGroup": "nessun gruppo",
+        "generatorLoading": "caricamento",
         "generatorLoadFromFile": "Carica da file",
         "dynamicPromptsRandom": "Prompt dinamici (casuali)",
         "dynamicPromptsCombinatorial": "Prompt dinamici (combinatori)",
+        "floatRangeGenerator": "Generatore di intervalli di numeri in virgola mobile",
+        "integerRangeGenerator": "Generatore di intervalli di numeri interi",
         "uniformRandomDistribution": "Distribuzione casuale uniforme",
         "generatorNRandomValues_one": "{{count}} valore casuale",
         "generatorNRandomValues_many": "{{count}} valori casuali",
@@ -1193,6 +1190,7 @@
         "loadWorkflowDesc2": "Il flusso di lavoro corrente presenta modifiche non salvate.",
         "downloadWorkflowError": "Errore durante lo scaricamento del flusso di lavoro",
         "deletedMissingNodeFieldFormElement": "Campo modulo mancante eliminato: nodo {{nodeId}} campo {{fieldName}}",
+        "loadingTemplates": "Caricamento {{name}}",
         "unableToUpdateNode": "Aggiornamento del nodo non riuscito: nodo {{node}} di tipo {{type}} (potrebbe essere necessario eliminarlo e ricrearlo)",
         "description": "Descrizione",
         "generatorImagesCategory": "Categoria",
@@ -1220,23 +1218,7 @@
             "alignmentUL": "In alto a sinistra",
             "alignmentDL": "In basso a sinistra",
             "alignmentUR": "In alto a destra"
-        },
-        "generatorLoading": "caricamento",
-        "addLinearView": "Aggiungi alla vista lineare",
-        "hideLegendNodes": "Nascondi legenda tipo di campo",
-        "mismatchedVersion": "Nodo non valido: il nodo {{node}} di tipo {{type}} ha una versione non corrispondente (provare ad aggiornare?)",
-        "noFieldsLinearview": "Nessun campo aggiunto alla vista lineare",
-        "removeLinearView": "Rimuovi dalla vista lineare",
-        "reorderLinearView": "Riordina vista lineare",
-        "showLegendNodes": "Mostra legenda tipo di campo",
-        "unableToLoadWorkflow": "Impossibile caricare il flusso di lavoro",
-        "unknownTemplate": "Modello sconosciuto",
-        "unknownInput": "Input sconosciuto: {{name}}",
-        "loadingTemplates": "Caricamento in corso {{name}}",
-        "versionUnknown": " Versione sconosciuta",
-        "generateValues": "Genera valori",
-        "floatRangeGenerator": "Generatore di intervallo di numeri decimali",
-        "integerRangeGenerator": "Generatore di intervallo di numeri interi"
+        }
     },
     "boards": {
         "autoAddBoard": "Aggiungi automaticamente bacheca",
@@ -1278,20 +1260,20 @@
         "shared": "Bacheche condivise",
         "addPrivateBoard": "Aggiungi una Bacheca Privata",
         "noBoards": "Nessuna bacheca {{boardType}}",
+        "hideBoards": "Nascondi bacheche",
+        "viewBoards": "Visualizza bacheche",
         "deletedPrivateBoardsCannotbeRestored": "Le bacheche e le immagini eliminate non possono essere ripristinate. Selezionando \"Elimina solo bacheca\", le immagini verranno spostate in uno stato privato e non categorizzato per l'autore dell'immagine.",
         "updateBoardError": "Errore durante l'aggiornamento della bacheca",
         "uncategorizedImages": "Immagini non categorizzate",
         "deleteAllUncategorizedImages": "Elimina tutte le immagini non categorizzate",
+        "deletedImagesCannotBeRestored": "Le immagini eliminate non possono essere ripristinate.",
         "locateInGalery": "Trova nella Galleria",
         "movingVideosToBoard_one": "Spostamento di {{count}} video sulla bacheca:",
         "movingVideosToBoard_many": "Spostamento di {{count}} video sulla bacheca:",
         "movingVideosToBoard_other": "Spostamento di {{count}} video sulla bacheca:",
         "videosWithCount_one": "{{count}} video",
         "videosWithCount_many": "{{count}} video",
-        "videosWithCount_other": "{{count}} video",
-        "deletedImagesCannotBeRestored": "Le immagini eliminate non possono essere ripristinate.",
-        "hideBoards": "Nascondi bacheche",
-        "viewBoards": "Visualizza le bacheche"
+        "videosWithCount_other": "{{count}} video"
     },
     "queue": {
         "queueFront": "Aggiungi all'inizio della coda",
@@ -1348,6 +1330,7 @@
         "clearQueueAlertDialog2": "Sei sicuro di voler cancellare la coda?",
         "item": "Elemento",
         "graphFailedToQueue": "Impossibile mettere in coda il grafico",
+        "batchFieldValues": "Valori Campi Lotto",
         "time": "Tempo",
         "openQueue": "Apri coda",
         "iterations_one": "Iterazione",
@@ -1360,7 +1343,7 @@
         "generations_many": "Generazioni",
         "generations_other": "Generazioni",
         "origin": "Origine",
-        "destination": "Dest",
+        "destination": "Destinazione",
         "upscaling": "Ampliamento",
         "canvas": "Tela",
         "workflows": "Flussi di lavoro",
@@ -1376,28 +1359,21 @@
         "retryItem": "Riesegui elemento",
         "retryFailed": "Problema riesecuzione elemento",
         "credits": "Crediti",
-        "cancelAllExceptCurrent": "Annulla tutto tranne quello corrente",
-        "sortColumn": "Ordina colonna",
-        "sortBy": "Ordina per {{column}}",
-        "sortOrderAscending": "Ascendente",
-        "sortOrderDescending": "Discendente",
-        "createdAt": "Creato",
-        "completedAt": "Completato",
-        "batchFieldValues": "Valori del campo Lotto"
+        "cancelAllExceptCurrent": "Annulla tutto tranne quello corrente"
     },
     "models": {
         "noMatchingModels": "Nessun modello corrispondente",
         "loading": "caricamento",
+        "noMatchingLoRAs": "Nessun LoRA corrispondente",
         "noModelsAvailable": "Nessun modello disponibile",
         "selectModel": "Seleziona un modello",
         "noRefinerModelsInstalled": "Nessun modello affinatore SDXL installato",
+        "noLoRAsInstalled": "Nessun LoRA installato",
         "addLora": "Aggiungi LoRA",
         "defaultVAE": "VAE predefinito",
         "concepts": "Concetti",
         "lora": "LoRA",
-        "noCompatibleLoRAs": "Nessun LoRA compatibile",
-        "noMatchingLoRAs": "Nessun LoRA corrispondente",
-        "noLoRAsInstalled": "Nessun LoRA installato"
+        "noCompatibleLoRAs": "Nessun LoRA compatibile"
     },
     "invocationCache": {
         "disable": "Disabilita",
@@ -1875,19 +1851,19 @@
         "scheduler": "Campionatore",
         "noModelsAvailable": "Nessun modello disponibile",
         "denoisingStrength": "Forza di riduzione del rumore",
+        "concatPromptStyle": "Collega Prompt & Stile",
         "loading": "Caricamento...",
         "steps": "Passi",
         "refinerStart": "Inizio Affinamento",
         "cfgScale": "Scala CFG",
+        "negStylePrompt": "Prompt Stile negativo",
         "refiner": "Affinatore",
         "negAestheticScore": "Punteggio estetico negativo",
         "refinermodel": "Modello Affinatore",
         "posAestheticScore": "Punteggio estetico positivo",
-        "refinerSteps": "Passi Affinamento",
-        "concatPromptStyle": "Collegamento di prompt e stile",
-        "freePromptStyle": "Prompt manuale Stile",
-        "negStylePrompt": "Prompt di stile negativo",
-        "posStylePrompt": "Prompt di stile positivo"
+        "posStylePrompt": "Prompt Stile positivo",
+        "freePromptStyle": "Prompt di stile manuale",
+        "refinerSteps": "Passi Affinamento"
     },
     "metadata": {
         "positivePrompt": "Prompt positivo",
@@ -1914,6 +1890,8 @@
         "allPrompts": "Tutti i prompt",
         "imageDimensions": "Dimensioni dell'immagine",
         "parameterSet": "Parametro {{parameter}} impostato",
+        "parsingFailed": "Analisi non riuscita",
+        "recallParameter": "Richiama {{label}}",
         "canvasV2Metadata": "Livelli Tela",
         "guidance": "Guida",
         "seamlessXAxis": "Asse X senza giunte",
@@ -1924,33 +1902,36 @@
         "videoModel": "Modello",
         "videoDuration": "Durata",
         "videoAspectRatio": "Proporzioni",
-        "videoResolution": "Risoluzione",
-        "parsingFailed": "Analisi non riuscita",
-        "recallParameter": "Richiama {{label}}"
+        "videoResolution": "Risoluzione"
     },
     "hrf": {
+        "enableHrf": "Abilita Correzione Alta Risoluzione",
+        "upscaleMethod": "Metodo di ampliamento",
         "metadata": {
             "strength": "Forza della Correzione Alta Risoluzione",
             "enabled": "Correzione Alta Risoluzione Abilitata",
             "method": "Metodo della Correzione Alta Risoluzione"
         },
-        "hrf": "Correzione Alta Risoluzione",
-        "enableHrf": "Abilita correzione ad alta risoluzione",
-        "upscaleMethod": "Metodo di ampliamento"
+        "hrf": "Correzione Alta Risoluzione"
     },
     "workflows": {
         "saveWorkflowAs": "Salva flusso di lavoro come",
         "workflowEditorMenu": "Menu dell'editor del flusso di lavoro",
         "workflowName": "Nome del flusso di lavoro",
         "saveWorkflow": "Salva flusso di lavoro",
+        "openWorkflow": "Apri flusso di lavoro",
+        "clearWorkflowSearchFilter": "Cancella il filtro di ricerca del flusso di lavoro",
         "workflowLibrary": "Libreria flussi di lavoro",
         "workflowSaved": "Flusso di lavoro salvato",
         "unnamedWorkflow": "Flusso di lavoro senza nome",
         "savingWorkflow": "Salvataggio del flusso di lavoro...",
+        "problemLoading": "Problema durante il caricamento dei flussi di lavoro",
         "loading": "Caricamento dei flussi di lavoro",
+        "searchWorkflows": "Cerca flussi di lavoro",
         "problemSavingWorkflow": "Problema durante il salvataggio del flusso di lavoro",
         "deleteWorkflow": "Elimina flusso di lavoro",
         "workflows": "Flussi di lavoro",
+        "noDescription": "Nessuna descrizione",
         "newWorkflowCreated": "Nuovo flusso di lavoro creato",
         "downloadWorkflow": "Salva su file",
         "uploadWorkflow": "Carica da file",
@@ -1967,6 +1948,9 @@
         "loadWorkflow": "$t(common.load) Flusso di lavoro",
         "autoLayout": "Schema automatico",
         "loadFromGraph": "Carica il flusso di lavoro dal grafico",
+        "userWorkflows": "Flussi di lavoro utente",
+        "projectWorkflows": "Flussi di lavoro del progetto",
+        "defaultWorkflows": "Flussi di lavoro predefiniti",
         "chooseWorkflowFromLibrary": "Scegli il flusso di lavoro dalla libreria",
         "deleteWorkflow2": "Vuoi davvero eliminare questo flusso di lavoro? Questa operazione non può essere annullata.",
         "edit": "Modifica",
@@ -1974,6 +1958,7 @@
         "copyShareLink": "Copia Condividi Link",
         "copyShareLinkForWorkflow": "Copia Condividi Link del Flusso di lavoro",
         "delete": "Elimina",
+        "openLibrary": "Apri la libreria",
         "builder": {
             "resetAllNodeFields": "Reimposta tutti i campi del nodo",
             "row": "Riga",
@@ -1995,7 +1980,9 @@
             "singleLine": "Linea singola",
             "multiLine": "Linea Multipla",
             "both": "Entrambi",
+            "emptyRootPlaceholderViewMode": "Fare clic su Modifica per iniziare a creare un modulo per questo flusso di lavoro.",
             "textPlaceholder": "Testo vuoto",
+            "workflowBuilderAlphaWarning": "Il generatore di flussi di lavoro è attualmente in versione alpha. Potrebbero esserci cambiamenti radicali prima della versione stabile.",
             "heading": "Intestazione",
             "divider": "Divisore",
             "container": "Contenitore",
@@ -2042,36 +2029,25 @@
             "errorWorkflowHasUnpublishableNodes": "Il flusso di lavoro ha nodi di estrazione lotto, generatore o metadati",
             "showShuffle": "Mostra Mescola",
             "shuffle": "Mescola",
-            "removeFromForm": "Rimuovi dal modulo",
-            "emptyRootPlaceholderViewMode": "Fare clic su Modifica per iniziare a creare un modulo per questo flusso di lavoro.",
-            "workflowBuilderAlphaWarning": "Il generatore di flussi di lavoro è attualmente in versione alpha. Potrebbero esserci modifiche sostanziali prima della versione stabile."
+            "removeFromForm": "Rimuovi dal modulo"
         },
         "loadMore": "Carica altro",
         "searchPlaceholder": "Cerca per nome, descrizione o etichetta",
+        "filterByTags": "Filtra per etichetta",
         "shared": "Condiviso",
         "browseWorkflows": "Sfoglia i flussi di lavoro",
+        "allLoaded": "Tutti i flussi di lavoro caricati",
         "saveChanges": "Salva modifiche",
         "yourWorkflows": "I tuoi flussi di lavoro",
         "recentlyOpened": "Aperto di recente",
         "workflowThumbnail": "Miniatura del flusso di lavoro",
         "private": "Privato",
         "deselectAll": "Deseleziona tutto",
+        "noRecentWorkflows": "Nessun flusso di lavoro recente",
         "view": "Visualizza",
         "recommended": "Consigliato per te",
         "emptyStringPlaceholder": "<stringa vuota>",
-        "published": "Pubblicato",
-        "defaultWorkflows": "Flussi di lavoro predefiniti",
-        "userWorkflows": "Flussi di lavoro dell'utente",
-        "projectWorkflows": "Flussi di lavoro del progetto",
-        "allLoaded": "Tutti i flussi di lavoro caricati",
-        "filterByTags": "Filtra per etichetta",
-        "noRecentWorkflows": "Nessun flusso di lavoro recente",
-        "openWorkflow": "Apri flusso di lavoro",
-        "problemLoading": "Problema nel caricamento dei flussi di lavoro",
-        "noDescription": "Nessuna descrizione",
-        "searchWorkflows": "Ricerca flussi di lavoro",
-        "clearWorkflowSearchFilter": "Cancella filtro di ricerca del flusso di lavoro",
-        "openLibrary": "Apri libreria"
+        "published": "Pubblicato"
     },
     "accordions": {
         "compositing": {
@@ -2098,17 +2074,14 @@
         "addPromptTrigger": "Aggiungi Trigger nel prompt",
         "noMatchingTriggers": "Nessun Trigger corrispondente",
         "discard": "Scarta",
+        "insert": "Inserisci",
         "replace": "Sostituisci",
+        "resultSubtitle": "Scegli come gestire il prompt espanso:",
+        "resultTitle": "Espansione del prompt completata",
         "expandingPrompt": "Espansione del prompt...",
         "uploadImageForPromptGeneration": "Carica l'immagine per la generazione del prompt",
         "expandCurrentPrompt": "Espandi il prompt corrente",
-        "generateFromImage": "Genera prompt dall'immagine",
-        "resultTitle": "Espansione del prompt completata",
-        "resultSubtitle": "Scegli come gestire il prompt espanso:",
-        "insert": "Inserisci",
-        "noPromptHistory": "Nessuna cronologia di prompt registrata.",
-        "noMatchingPrompts": "Nessun prompt corrispondente nella cronologia.",
-        "toSwitchBetweenPrompts": "per passare da un prompt all'altro."
+        "generateFromImage": "Genera prompt dall'immagine"
     },
     "controlLayers": {
         "addLayer": "Aggiungi Livello",
@@ -2117,6 +2090,7 @@
         "moveForward": "Sposta avanti",
         "moveBackward": "Sposta indietro",
         "autoNegative": "Auto Negativo",
+        "deletePrompt": "Cancella il prompt",
         "rectangle": "Rettangolo",
         "addPositivePrompt": "Aggiungi $t(controlLayers.prompt)",
         "addNegativePrompt": "Aggiungi $t(controlLayers.negativePrompt)",
@@ -2133,8 +2107,10 @@
         "newCanvasFromImage": "Nuova tela da immagine",
         "globalReferenceImage": "Immagine di riferimento Globale",
         "copyToClipboard": "Copia negli appunti",
+        "sendingToCanvas": "Effettua le generazioni nella Tela",
         "clearHistory": "Cancella la cronologia",
         "inpaintMask": "Maschera Inpaint",
+        "sendToGallery": "Invia alla Galleria",
         "controlLayer": "Livello di Controllo",
         "rasterLayer_withCount_one": "$t(controlLayers.rasterLayer)",
         "rasterLayer_withCount_many": "Livelli Raster",
@@ -2148,6 +2124,7 @@
         "addControlLayer": "Aggiungi $t(controlLayers.controlLayer)",
         "addInpaintMask": "Aggiungi $t(controlLayers.inpaintMask)",
         "addRegionalGuidance": "Aggiungi $t(controlLayers.regionalGuidance)",
+        "sendToCanvasDesc": "Premendo Invoke il lavoro in corso viene visualizzato sulla tela.",
         "addRasterLayer": "Aggiungi $t(controlLayers.rasterLayer)",
         "clearCaches": "Svuota le cache",
         "regionIsEmpty": "La regione selezionata è vuota",
@@ -2168,7 +2145,12 @@
         "showHUD": "Mostra HUD",
         "maskFill": "Riempimento maschera",
         "addReferenceImage": "Aggiungi $t(controlLayers.referenceImage)",
+        "addGlobalReferenceImage": "Aggiungi $t(controlLayers.globalReferenceImage)",
+        "sendingToGallery": "Inviare generazioni alla Galleria",
+        "sendToGalleryDesc": "Premendo Invoke viene generata e salvata un'immagine unica nella tua galleria.",
         "sendToCanvas": "Invia alla Tela",
+        "viewProgressInViewer": "Visualizza i progressi e i risultati nel <Btn>Visualizzatore immagini</Btn>.",
+        "viewProgressOnCanvas": "Visualizza i progressi e i risultati nella <Btn>Tela</Btn>.",
         "saveBboxToGallery": "Salva il riquadro di delimitazione nella Galleria",
         "cropLayerToBbox": "Ritaglia il livello al riquadro di delimitazione",
         "savedToGalleryError": "Errore durante il salvataggio nella galleria",
@@ -2190,6 +2172,9 @@
         "pullBboxIntoReferenceImageOk": "Contenuto del riquadro inserito nell'immagine di riferimento",
         "pullBboxIntoLayerOk": "Riquadro caricato nel livello",
         "pullBboxIntoReferenceImageError": "Problema nell'inserimento del contenuto del riquadro nell'immagine di riferimento",
+        "globalReferenceImage_withCount_one": "$t(controlLayers.globalReferenceImage)",
+        "globalReferenceImage_withCount_many": "Immagini di riferimento Globali",
+        "globalReferenceImage_withCount_other": "Immagini di riferimento Globali",
         "controlMode": {
             "balanced": "Bilanciato (consigliato)",
             "controlMode": "Modalità di controllo",
@@ -2200,6 +2185,7 @@
         "negativePrompt": "Prompt Negativo",
         "prompt": "Prompt Positivo",
         "beginEndStepPercentShort": "Inizio/Fine %",
+        "stagingOnCanvas": "Genera immagini nella",
         "ipAdapterMethod": {
             "full": "Stile e Composizione",
             "style": "Stile (semplice)",
@@ -2348,6 +2334,8 @@
                 "value": "Valore (HSV)"
             }
         },
+        "controlLayers_withCount_hidden": "Livelli di controllo ({{count}} nascosti)",
+        "regionalGuidance_withCount_hidden": "Guida regionale ({{count}} nascosti)",
         "fill": {
             "grid": "Griglia",
             "crosshatch": "Tratteggio incrociato",
@@ -2356,18 +2344,28 @@
             "solid": "Solido",
             "vertical": "Verticale",
             "horizontal": "Orizzontale",
-            "diagonal": "Diagonale",
-            "bgFillColor": "Colore di sfondo",
-            "fgFillColor": "Colore di primo piano"
+            "diagonal": "Diagonale"
         },
+        "rasterLayers_withCount_hidden": "Livelli raster ({{count}} nascosti)",
+        "inpaintMasks_withCount_hidden": "Maschere Inpaint ({{count}} nascoste)",
+        "regionalGuidance_withCount_visible": "Guide regionali ({{count}})",
         "locked": "Bloccato",
         "hidingType": "Nascondere {{type}}",
         "logDebugInfo": "Registro Info Debug",
+        "inpaintMasks_withCount_visible": "Maschere Inpaint ({{count}})",
         "layer_one": "Livello",
         "layer_many": "Livelli",
         "layer_other": "Livelli",
         "disableTransparencyEffect": "Disabilita l'effetto trasparenza",
+        "controlLayers_withCount_visible": "Livelli di controllo ({{count}})",
         "transparency": "Trasparenza",
+        "newCanvasSessionDesc": "Questo cancellerà la tela e tutte le impostazioni, eccetto la selezione del modello. Le generazioni saranno effettuate sulla tela.",
+        "rasterLayers_withCount_visible": "Livelli raster ({{count}})",
+        "globalReferenceImages_withCount_visible": "Immagini di riferimento Globali ({{count}})",
+        "globalReferenceImages_withCount_hidden": "Immagini di riferimento globali ({{count}} nascoste)",
+        "layer_withCount_one": "Livello ({{count}})",
+        "layer_withCount_many": "Livelli ({{count}})",
+        "layer_withCount_other": "Livelli ({{count}})",
         "unlocked": "Sbloccato",
         "enableTransparencyEffect": "Abilita l'effetto trasparenza",
         "replaceLayer": "Sostituisci livello",
@@ -2375,6 +2373,9 @@
         "pullBboxIntoReferenceImage": "Carica l'immagine delimitata nel riquadro",
         "showProgressOnCanvas": "Mostra i progressi sulla Tela",
         "weight": "Peso",
+        "newGallerySession": "Nuova sessione Galleria",
+        "newGallerySessionDesc": "Questo cancellerà la tela e tutte le impostazioni, eccetto la selezione del modello. Le generazioni saranno inviate alla galleria.",
+        "newCanvasSession": "Nuova sessione Tela",
         "deleteSelected": "Elimina selezione",
         "settings": {
             "isolatedStagingPreview": "Anteprima di generazione isolata",
@@ -2415,8 +2416,8 @@
             "accept": "Accetta",
             "saveToGallery": "Salva nella Galleria",
             "previous": "Precedente",
-            "showResultsOn": "Visualizzare i risultati",
-            "showResultsOff": "Nascondere i risultati"
+            "showResultsOn": "Risultati visualizzati",
+            "showResultsOff": "Risultati nascosti"
         },
         "HUD": {
             "bbox": "Riquadro di delimitazione",
@@ -2448,6 +2449,7 @@
             "copyBboxToClipboard": "Copia il riquadro di delimitazione negli appunti",
             "newResizedControlLayer": "Nuovo livello di controllo ridimensionato"
         },
+        "newImg2ImgCanvasFromImage": "Nuova Immagine da immagine",
         "copyRasterLayerTo": "Copia $t(controlLayers.rasterLayer) in",
         "copyControlLayerTo": "Copia $t(controlLayers.controlLayer) in",
         "copyInpaintMaskTo": "Copia $t(controlLayers.inpaintMask) in",
@@ -2455,6 +2457,7 @@
             "dragToMove": "Trascina un punto per spostarlo",
             "clickToAdd": "Fare clic sul livello per aggiungere un punto",
             "clickToRemove": "Clicca su un punto per rimuoverlo",
+            "help3": "Inverte la selezione per selezionare tutto tranne l'oggetto di destinazione.",
             "pointType": "Tipo punto",
             "apply": "Applica",
             "reset": "Reimposta",
@@ -2466,16 +2469,8 @@
             "neutral": "Neutro",
             "saveAs": "Salva come",
             "process": "Elabora",
-            "desc": "Seleziona un singolo oggetto di destinazione. Una volta completata la selezione, fai clic su <Bold>Applica</Bold> per eliminare tutto ciò che si trova al di fuori dell'area selezionata, oppure salva la selezione come nuovo livello.",
-            "visualModeDesc": "La modalità visiva utilizza input di tipo riquadro e punto per selezionare un oggetto.",
-            "visualMode1": "Fai clic e trascina per disegnare un riquadro attorno all'oggetto che desideri selezionare. Puoi ottenere risultati migliori disegnando il riquadro un po' più grande o più piccolo dell'oggetto.",
-            "visualMode2": "Fare clic per aggiungere un punto di <Bold>iinclusione</Bold>i verde oppure fare clic tenendo premuto Maiusc per aggiungere un punto di <Bold>iesclusione</Bold>i rosso per indicare al modello cosa includere o escludere.",
-            "visualMode3": "I punti possono essere utilizzati per perfezionare una selezione di caselle oppure in modo indipendente.",
-            "promptModeDesc": "La modalità Prompt utilizza l'input di testo per selezionare un oggetto.",
-            "promptMode1": "Digitare una breve descrizione dell'oggetto che si desidera selezionare.",
-            "promptMode2": "Utilizzare un linguaggio semplice, evitando descrizioni complesse o oggetti multipli.",
-            "model": "Modello",
-            "prompt": "Prompt di selezione"
+            "help1": "Seleziona un singolo oggetto di destinazione. Aggiungi i punti <Bold>Includi</Bold> e <Bold>Escludi</Bold> per indicare quali parti del livello fanno parte dell'oggetto di destinazione.",
+            "help2": "Inizia con un punto <Bold>Include</Bold> all'interno dell'oggetto di destinazione. Aggiungi altri punti per perfezionare la selezione. Meno punti in genere producono risultati migliori."
         },
         "convertControlLayerTo": "Converti $t(controlLayers.controlLayer) in",
         "newRasterLayer": "Nuovo $t(controlLayers.rasterLayer)",
@@ -2486,6 +2481,7 @@
         "convertRegionalGuidanceTo": "Converti $t(controlLayers.regionalGuidance) in",
         "newControlLayer": "Nuovo $t(controlLayers.controlLayer)",
         "newInpaintMask": "Nuova $t(controlLayers.inpaintMask)",
+        "replaceCurrent": "Sostituisci corrente",
         "mergeDown": "Unire in basso",
         "mergingLayers": "Unione dei livelli",
         "controlLayerEmptyState": "<UploadButton>Carica un'immagine</UploadButton>, trascina un'immagine dalla galleria su questo livello, <PullBboxButton>trascina il riquadro di delimitazione in questo livello</PullBboxButton> oppure disegna sulla tela per iniziare.",
@@ -2499,6 +2495,7 @@
         "newSession": "Nuova sessione",
         "resetCanvasLayers": "Ripristina livelli Tela",
         "referenceImageRegional": "Immagine di riferimento (regionale)",
+        "referenceImageGlobal": "Immagine di riferimento (globale)",
         "warnings": {
             "controlAdapterNoModelSelected": "nessun modello selezionato per il livello di controllo",
             "controlAdapterNoControl": "nessun controllo selezionato/disegnato",
@@ -2524,6 +2521,7 @@
         "pasteToBbox": "Riquadro di delimitazione",
         "pasteToCanvas": "Tela",
         "pasteToCanvasDesc": "Nuovo livello (nella Tela)",
+        "pastedTo": "Incollato su {{destination}}",
         "regionCopiedToClipboard": "{{region}} Copiato negli appunti",
         "errors": {
             "unableToFindImage": "Impossibile trovare l'immagine",
@@ -2546,66 +2544,16 @@
         "showNonRasterLayers": "Mostra livelli non raster (Shift+H)",
         "hideNonRasterLayers": "Nascondi livelli non raster (Shift+H)",
         "referenceImageEmptyStateWithCanvasOptions": "<UploadButton>Carica un'immagine</UploadButton>, trascina un'immagine dalla galleria su questa immagine di riferimento o <PullBboxButton>trascina il riquadro di delimitazione in questa immagine di riferimento</PullBboxButton> per iniziare.",
+        "uploadOrDragAnImage": "Trascina un'immagine dalla galleria o <UploadButton>carica un'immagine</UploadButton>.",
         "autoSwitch": {
-            "off": "Spento",
             "switchOnStart": "All'inizio",
-            "switchOnFinish": "Alla fine"
+            "switchOnFinish": "Alla fine",
+            "off": "Spento"
         },
         "invertMask": "Inverti maschera",
         "fitBboxToMasks": "Adatta il riquadro di delimitazione alle maschere",
         "maxRefImages": "Max Immagini di rif.to",
-        "useAsReferenceImage": "Usa come immagine di riferimento",
-        "globalReferenceImage_withCount_one": "$t(controlLayers.globalReferenceImage)",
-        "globalReferenceImage_withCount_many": "Immagini di riferimento globali",
-        "globalReferenceImage_withCount_other": "Immagini di riferimento globali",
-        "layer_withCount_one": "Livello ({{count}})",
-        "layer_withCount_many": "Livelli ({{count}})",
-        "layer_withCount_other": "Livelli ({{count}})",
-        "addAdjustments": "Aggiungi regolazioni",
-        "removeAdjustments": "Rimuovi regolazioni",
-        "adjustments": {
-            "simple": "Semplice",
-            "curves": "Curve",
-            "heading": "Regolazioni",
-            "expand": "Espandi regolazioni",
-            "collapse": "Comprimi regolazioni",
-            "brightness": "Luminosità",
-            "contrast": "Contrasto",
-            "saturation": "Saturazione",
-            "temperature": "Temperatura",
-            "tint": "Tinta",
-            "sharpness": "Nitidezza",
-            "reset": "Reimposta"
-        },
-        "deletePrompt": "Elimina prompt",
-        "addGlobalReferenceImage": "Aggiungi $t(controlLayers.globalReferenceImage)",
-        "referenceImageGlobal": "Immagine di riferimento (globale)",
-        "sendingToGallery": "Invia generazioni alla Galleria",
-        "sendToGallery": "Invia alla Galleria",
-        "sendToGalleryDesc": "Premendo Invoke viene generata e salvata un'immagine unica nella tua galleria.",
-        "newImg2ImgCanvasFromImage": "Nuovo immagine-a-immagine da Immagine",
-        "sendToCanvasDesc": "Premendo Invoke il lavoro in corso viene visualizzato sulla tela.",
-        "viewProgressOnCanvas": "Visualizza i progressi e gli output nel <Btn>Visualizzatore immagini</Btn>.",
-        "regionalGuidance_withCount_hidden": "Guida regionale ({{count}} nascosti)",
-        "controlLayers_withCount_hidden": "Livelli di controllo ({{count}} nascosti)",
-        "rasterLayers_withCount_hidden": "Livelli raster ({{count}} nascosti)",
-        "globalReferenceImages_withCount_hidden": "Immagini di riferimento globali ({{count}} nascoste)",
-        "inpaintMasks_withCount_hidden": "Maschere Inpaint ({{count}} nascoste)",
-        "regionalGuidance_withCount_visible": "Guida regionale ({{count}})",
-        "controlLayers_withCount_visible": "Livelli di controllo ({{count}})",
-        "rasterLayers_withCount_visible": "Livelli raster ({{count}})",
-        "globalReferenceImages_withCount_visible": "Immagini di riferimento globali ({{count}})",
-        "inpaintMasks_withCount_visible": "Maschere Inpaint ({{count}})",
-        "pastedTo": "Incollato su {{destination}}",
-        "stagingOnCanvas": "Predisponi le immagini su",
-        "newGallerySession": "Nuova sessione della Galleria",
-        "newGallerySessionDesc": "Questo cancellerà la tela e tutte le impostazioni, ad eccezione della selezione del modello. Le generazioni verranno inviate alla galleria.",
-        "newCanvasSession": "Nuova sessione Tela",
-        "newCanvasSessionDesc": "Questo cancellerà la tela e tutte le impostazioni, ad eccezione della selezione del modello. Le generazioni verranno predisposte sulla tela.",
-        "replaceCurrent": "Sostituisci l'attuale",
-        "uploadOrDragAnImage": "Trascina un'immagine dalla galleria o <UploadButton>carica un'immagine</UploadButton>.",
-        "sendingToCanvas": "Predisponi le generazioni sulla Tela",
-        "viewProgressInViewer": "Visualizza i progressi e gli output nel <Btn>Visualizzatore immagini</Btn>."
+        "useAsReferenceImage": "Usa come immagine di riferimento"
     },
     "ui": {
         "tabs": {
@@ -2699,13 +2647,13 @@
                 "canvasCalloutLink": "Per ulteriori funzionalità, vai su Tela."
             },
             "videoTitle": "Genera video da prompt testuale.",
-            "addStartingFrame": {
-                "title": "Aggiungi un fotogramma iniziale",
-                "description": "Aggiungi un'immagine per controllare il primo fotogramma del tuo video."
-            },
             "video": {
                 "startingFrameCalloutTitle": "Aggiungi un fotogramma iniziale",
                 "startingFrameCalloutDesc": "Aggiungi un'immagine per controllare il primo fotogramma del tuo video."
+            },
+            "addStartingFrame": {
+                "title": "Aggiungi un fotogramma iniziale",
+                "description": "Aggiungi un'immagine per controllare il primo fotogramma del tuo video."
             }
         },
         "panels": {
@@ -2802,12 +2750,11 @@
         "whatsNewInInvoke": "Novità in Invoke",
         "readReleaseNotes": "Leggi le note di rilascio",
         "watchRecentReleaseVideos": "Guarda i video su questa versione",
+        "watchUiUpdatesOverview": "Guarda le novità dell'interfaccia",
         "items": [
-            "Seleziona oggetto v2: selezione degli oggetti migliorata con input di punti e riquadri o prompt di testo.",
-            "Regolazioni del livello raster: regola facilmente la luminosità, il contrasto, la saturazione, le curve e altro ancora del livello.",
-            "Cronologia prompt: rivedi e richiama rapidamente i tuoi ultimi 100 prompt."
-        ],
-        "watchUiUpdatesOverview": "Guarda la panoramica degli aggiornamenti dell'interfaccia utente"
+            "Tela: Color Picker non campiona l'alfa, il riquadro di delimitazione rispetta il blocco delle proporzioni quando si ridimensiona il pulsante Mescola per i campi numerici nel generatore di flusso di lavoro, nasconde i cursori delle dimensioni dei pixel quando si utilizza un modello che non li supporta",
+            "Flussi di lavoro: aggiunto un pulsante Mescola ai campi di input numerici"
+        ]
     },
     "system": {
         "logLevel": {
@@ -2856,9 +2803,6 @@
         "clearSucceeded": "Cache del modello cancellata",
         "clearFailed": "Problema durante la cancellazione della cache del modello"
     },
-    "lora": {
-        "weight": "Peso"
-    },
     "video": {
         "noVideoSelected": "Nessun video selezionato",
         "selectFromGallery": "Seleziona un video dalla galleria per riprodurlo"

invokeai/frontend/web/public/locales/ja.json

@@ -27,6 +27,7 @@
         "openInNewTab": "新しいタブで開く",
         "controlNet": "コントロールネット",
         "linear": "リニア",
+        "imageFailedToLoad": "画像が読み込めません",
         "modelManager": "モデルマネージャー",
         "learnMore": "もっと学ぶ",
         "random": "ランダム",
@@ -55,6 +56,7 @@
         "details": "詳細",
         "inpaint": "inpaint",
         "delete": "削除",
+        "nextPage": "次のページ",
         "copy": "コピー",
         "error": "エラー",
         "file": "ファイル",
@@ -62,10 +64,13 @@
         "input": "インプット",
         "format": "形式",
         "installed": "インストール済み",
+        "localSystem": "ローカルシステム",
         "outputs": "アウトプット",
+        "prevPage": "前のページ",
         "unknownError": "未知のエラー",
         "orderBy": "並び順:",
         "enabled": "有効",
+        "notInstalled": "未 $t(common.installed)",
         "positivePrompt": "ポジティブプロンプト",
         "negativePrompt": "ネガティブプロンプト",
         "selected": "選択済み",
@@ -91,6 +96,7 @@
         "close": "閉じる",
         "warnings": "警告",
         "dontShowMeThese": "次回から表示しない",
+        "goTo": "移動",
         "generating": "生成中",
         "loadingModel": "モデルをロード中",
         "layout": "レイアウト",
@@ -101,6 +107,7 @@
         "min": "最小",
         "max": "最大",
         "values": "値",
+        "resetToDefaults": "デフォルトに戻す",
         "row": "行",
         "column": "列",
         "board": "ボード",
@@ -124,6 +131,7 @@
     "gallery": {
         "galleryImageSize": "画像のサイズ",
         "gallerySettings": "ギャラリーの設定",
+        "noImagesInGallery": "表示する画像がありません",
         "autoSwitchNewImages": "新しい画像に自動切替",
         "copy": "コピー",
         "image": "画像",
@@ -137,6 +145,7 @@
         "deleteImage_other": "画像 {{count}} 枚を削除",
         "deleteImagePermanent": "削除された画像は復元できません。",
         "download": "ダウンロード",
+        "unableToLoad": "ギャラリーをロードできません",
         "bulkDownloadRequested": "ダウンロード準備中",
         "bulkDownloadRequestedDesc": "ダウンロードの準備中です。しばらくお待ちください。",
         "bulkDownloadRequestFailed": "ダウンロード準備中に問題が発生",
@@ -151,6 +160,7 @@
         "compareImage": "比較画像",
         "openInViewer": "ビューアで開く",
         "selectForCompare": "比較対象として選択",
+        "selectAnImageToCompare": "比較する画像を選択",
         "slider": "スライダー",
         "sideBySide": "横並び",
         "hover": "ホバー",
@@ -162,6 +172,8 @@
         "compareHelp4": "<Kbd>[Z</Kbd>]または<Kbd>[Esc</Kbd>]を押して終了します。",
         "compareHelp2": "<Kbd>M</Kbd> キーを押して比較モードを切り替えます。",
         "move": "移動",
+        "openViewer": "ビューアを開く",
+        "closeViewer": "ビューアを閉じる",
         "exitSearch": "画像検索を終了",
         "oldestFirst": "最古から",
         "showStarredImagesFirst": "スター付き画像を最初に",
@@ -170,6 +182,7 @@
         "searchImages": "メタデータで検索",
         "gallery": "ギャラリー",
         "newestFirst": "最新から",
+        "jump": "ジャンプ",
         "go": "進む",
         "sortDirection": "並び替え順",
         "displayBoardSearch": "ボード検索",
@@ -592,6 +605,7 @@
         "scanResults": "結果をスキャン",
         "scanPlaceholder": "ローカルフォルダへのパス",
         "typePhraseHere": "ここにフレーズを入力",
+        "ipAdapters": "IPアダプター",
         "modelImageUpdated": "モデル画像アップデート",
         "installAll": "全てインストール",
         "installRepo": "リポジトリをインストール",
@@ -633,6 +647,7 @@
         "spandrelImageToImage": "Image to Image(スパンドレル)",
         "starterBundles": "スターターバンドル",
         "starterModels": "スターターモデル",
+        "starterModelsInModelManager": "スターターモデルがモデルマネージャーで見つかりました",
         "modelImageDeleteFailed": "モデル画像の削除失敗",
         "urlForbidden": "このモデルにアクセスできません",
         "urlForbiddenErrorMessage": "このモデルを配布しているサイトからリクエスト権限が必要かもしれません.",
@@ -641,10 +656,12 @@
         "inplaceInstall": "定位置にインストール",
         "fileSize": "ファイルサイズ",
         "modelPickerFallbackNoModelsInstalled2": "<LinkComponent>モデルマネージャー</LinkComponent> にアクセスしてモデルをインストールしてください.",
+        "filterModels": "フィルターモデル",
         "modelPickerFallbackNoModelsInstalled": "モデルがインストールされていません.",
         "manageModels": "モデル管理",
         "hfTokenReset": "ハギングフェイストークンリセット",
         "relatedModels": "関連のあるモデル",
+        "showOnlyRelatedModels": "関連している",
         "installedModelsCount": "{{total}} モデルのうち {{installed}} 個がインストールされています。",
         "allNModelsInstalled": "{{count}} 個のモデルがすべてインストールされています",
         "nToInstall": "{{count}}個をインストールする",
@@ -661,8 +678,12 @@
             "scanFolderDescription": "ローカルフォルダをスキャンしてモデルを自動的に検出し、インストールします。",
             "recommendedModels": "推奨モデル",
             "exploreStarter": "または、利用可能なすべてのスターターモデルを参照してください",
+            "quickStart": "クイックスタートバンドル",
             "bundleDescription": "各バンドルには各モデルファミリーの必須モデルと、開始するための厳選されたベースモデルが含まれています。",
-            "sdxl": "SDXL"
+            "browseAll": "または、利用可能なすべてのモデルを参照してください。",
+            "stableDiffusion15": "Stable Diffusion1.5",
+            "sdxl": "SDXL",
+            "fluxDev": "FLUX.1 dev"
         }
     },
     "parameters": {
@@ -678,10 +699,12 @@
         "scaleBeforeProcessing": "処理前のスケール",
         "scaledWidth": "幅のスケール",
         "scaledHeight": "高さのスケール",
+        "downloadImage": "画像をダウンロード",
         "usePrompt": "プロンプトを使用",
         "useSeed": "シード値を使用",
         "useAll": "すべてを使用",
         "info": "情報",
+        "showOptionsPanel": "サイドパネルを表示 (O or T)",
         "iterations": "生成回数",
         "general": "基本設定",
         "setToOptimalSize": "サイズをモデルに最適化",
@@ -695,6 +718,7 @@
             "collectionNumberLTExclusiveMin": "{{value}} <= {{exclusiveMinimum}} (最小値を除く)",
             "missingInputForField": "入力の欠落",
             "noModelSelected": "モデルが選択されていません",
+            "emptyBatches": "空のバッチ",
             "collectionStringTooLong": "長すぎます,最大{{maxLength}}",
             "batchNodeCollectionSizeMismatchNoGroupId": "バッチグループのコレクションサイズが合いません",
             "invoke": "呼び出す",
@@ -706,6 +730,7 @@
             "missingNodeTemplate": "ノードテンプレートの欠落",
             "batchNodeNotConnected": "バッチノードが: {{label}}につながっていない",
             "collectionNumberLTMin": "{{value}} < {{minimum}} (最小増加)",
+            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), スケーリングされたbboxの高さは{{height}}です",
             "fluxModelMultipleControlLoRAs": "コントロールLoRAは1度に1つしか使用できません",
             "noPrompts": "プロンプトが生成されません",
             "noNodesInGraph": "グラフにノードがありません",
@@ -713,6 +738,7 @@
             "canvasIsFiltering": "キャンバスがビジー状態(フィルタリング)",
             "canvasIsCompositing": "キャンバスがビジー状態(合成)",
             "systemDisconnected": "システムが切断されました",
+            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), 拡大縮小されたbboxの幅は{{width}}です",
             "canvasIsTransforming": "キャンバスがビジー状態(変換)",
             "canvasIsRasterizing": "キャンバスがビジー状態(ラスタライズ)",
             "modelIncompatibleBboxHeight": "Bboxの高さは{{height}}ですが，{{model}}は{{multiple}}の倍数が必要です",
@@ -720,6 +746,8 @@
             "modelIncompatibleBboxWidth": "Bboxの幅は{{width}}ですが, {{model}}は{{multiple}}の倍数が必要です",
             "modelIncompatibleScaledBboxWidth": "bboxの幅は{{width}}ですが，{{model}}は{{multiple}}の倍数が必要です",
             "canvasIsSelectingObject": "キャンバスがビジー状態(オブジェクトの選択)",
+            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), bboxの幅は{{width}}です",
+            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), bboxの高さは{{height}}です",
             "noFLUXVAEModelSelected": "FLUX生成にVAEモデルが選択されていません",
             "noT5EncoderModelSelected": "FLUX生成にT5エンコーダモデルが選択されていません",
             "modelDisabledForTrial": "{{modelName}} を使用した生成はトライアルアカウントではご利用いただけません.アカウント設定にアクセスしてアップグレードしてください。",
@@ -797,6 +825,8 @@
         "enableHighlightFocusedRegions": "重点領域を強調表示",
         "clearIntermediatesDesc1": "中間物をクリアすると、キャンバスとコントロールネットの状態がリセットされます.",
         "showProgressInViewer": "ビューアで進行状況画像を表示する",
+        "modelDescriptionsDisabled": "ドロップダウンのモデル説明が無効になっています",
+        "modelDescriptionsDisabledDesc": "ドロップダウンのモデル説明が無効になっています.設定で有効にしてください.",
         "clearIntermediatesDisabled": "中間物をクリアするにはキューが空でなければなりません",
         "clearIntermediatesDesc2": "中間画像は生成時に生成される副産物であり、ギャラリーに表示される結果画像とは異なります.中間画像を削除するとディスク容量が解放されます.",
         "intermediatesClearedFailed": "中間物をクリアする問題",
@@ -827,9 +857,11 @@
         "imagesWillBeAddedTo": "アップロードされた画像はボード {{boardName}} のアセットに追加されます.",
         "layerCopiedToClipboard": "レイヤーがクリップボードにコピーされました",
         "pasteFailed": "貼り付け失敗",
+        "imageSavingFailed": "画像保存に失敗しました",
         "importSuccessful": "インポートが成功しました",
         "problemDownloadingImage": "画像をダウンロードできません",
         "modelAddedSimple": "モデルがキューに追加されました",
+        "uploadFailedInvalidUploadDesc_withCount_other": "PNG、JPEG、または WEBP 画像は最大 1 つにする必要があります.",
         "outOfMemoryErrorDesc": "現在の生成設定はシステム容量を超えています.設定を調整してもう一度お試しください.",
         "parametersSet": "パラメーターが呼び出されました",
         "modelImportCanceled": "モデルのインポートがキャンセルされました",
@@ -844,11 +876,14 @@
         "linkCopied": "リンクがコピーされました",
         "unableToLoadImage": "画像をロードできません",
         "unableToLoadImageMetadata": "画像のメタデータをロードできません",
+        "imageSaved": "画像が保存されました",
         "importFailed": "インポートに失敗しました",
+        "invalidUpload": "無効なアップロードです",
         "outOfMemoryError": "メモリ不足エラー",
         "parameterSetDesc": "{{parameter}}を呼び出し",
         "errorCopied": "エラーがコピーされました",
         "sentToCanvas": "キャンバスに送信",
+        "setControlImage": "コントロール画像としてセット",
         "workflowLoaded": "ワークフローがロードされました",
         "unableToCopy": "コピーできません",
         "unableToCopyDesc": "あなたのブラウザはクリップボードアクセスをサポートしていません.Firefoxユーザーの場合は、以下の手順で修正できる可能性があります. ",
@@ -862,23 +897,32 @@
         "parameterNotSetDescWithMessage": "{{parameter}}: {{message}}を呼び出せません",
         "problemCopyingLayer": "レイヤーをコピーできません",
         "problemSavingLayer": "レイヤー保存ができません",
+        "setNodeField": "ノードフィールドとしてセット",
+        "layerSavedToAssets": "レイヤーがアセットに保存されました",
         "outOfMemoryErrorDescLocal": "OOM を削減するには、<LinkComponent>低 VRAM ガイド</LinkComponent> に従ってください.",
         "parameterNotSet": "パラメーターが呼び出されていません",
         "addedToBoard": "{{name}} 個の資産をボードに追加しました",
         "addedToUncategorized": "$t(boards.uncategorized)個のアセットがボードに追加されました",
         "problemDeletingWorkflow": "ワークフローが削除された問題",
+        "imageNotLoadedDesc": "画像を見つけられません",
         "parameterNotSetDesc": "{{parameter}}を呼び出せません",
         "chatGPT4oIncompatibleGenerationMode": "ChatGPT 4oは,テキストから画像への生成と画像から画像への生成のみをサポートしています.インペインティングおよび,アウトペインティングタスクには他のモデルを使用してください.",
         "imagenIncompatibleGenerationMode": "Google {{model}} はテキストから画像への変換のみをサポートしています. 画像から画像への変換, インペインティング,アウトペインティングのタスクには他のモデルを使用してください.",
+        "noRasterLayers": "ラスターレイヤーが見つかりません",
+        "noRasterLayersDesc": "PSDにエクスポートするには、少なくとも1つのラスターレイヤーを作成します",
+        "noActiveRasterLayers": "アクティブなラスターレイヤーがありません",
+        "noActiveRasterLayersDesc": "PSD にエクスポートするには、少なくとも 1 つのラスター レイヤーを有効にします",
         "noVisibleRasterLayers": "表示されるラスター レイヤーがありません",
         "noVisibleRasterLayersDesc": "PSD にエクスポートするには、少なくとも 1 つのラスター レイヤーを有効にします",
         "invalidCanvasDimensions": "キャンバスのサイズが無効です",
         "canvasTooLarge": "キャンバスが大きすぎます",
         "canvasTooLargeDesc": "キャンバスのサイズがPSDエクスポートの最大許容サイズを超えています。キャンバス全体の幅と高さを小さくしてから、もう一度お試しください。",
+        "failedToProcessLayers": "レイヤーの処理に失敗しました",
         "psdExportSuccess": "PSDエクスポート完了",
         "psdExportSuccessDesc": "{{count}} 個のレイヤーを PSD ファイルに正常にエクスポートしました",
         "problemExportingPSD": "PSD のエクスポート中に問題が発生しました",
         "canvasManagerNotAvailable": "キャンバスマネージャーは利用できません",
+        "noValidLayerAdapters": "有効なレイヤーアダプタが見つかりません",
         "fluxKontextIncompatibleGenerationMode": "Flux Kontext はテキストから画像への変換のみをサポートしています。画像から画像への変換、インペインティング、アウトペインティングのタスクには他のモデルを使用してください。",
         "promptGenerationStarted": "プロンプト生成が開始されました",
         "uploadAndPromptGenerationFailed": "画像のアップロードとプロンプトの生成に失敗しました",
@@ -910,6 +954,7 @@
         "positivePrompt": "ポジティブプロンプト",
         "strength": "Image to Image 強度",
         "recallParameters": "パラメータを再使用",
+        "recallParameter": "{{label}} を再使用",
         "imageDimensions": "画像サイズ",
         "imageDetails": "画像の詳細",
         "model": "モデル",
@@ -924,6 +969,7 @@
         "cfgRescaleMultiplier": "$t(parameters.cfgRescaleMultiplier)",
         "canvasV2Metadata": "キャンバス",
         "guidance": "手引き",
+        "parsingFailed": "解析に失敗しました",
         "seamlessXAxis": "シームレスX軸",
         "seamlessYAxis": "シームレスY軸",
         "parameterSet": "パラメーター {{parameter}} が設定されました",
@@ -981,6 +1027,7 @@
         "clearQueueAlertDialog2": "キューをクリアしてもよろしいですか？",
         "item": "項目",
         "graphFailedToQueue": "グラフをキューに追加できませんでした",
+        "batchFieldValues": "バッチの詳細",
         "openQueue": "キューを開く",
         "time": "時間",
         "completedIn": "完了まで",
@@ -1010,12 +1057,14 @@
     "models": {
         "noMatchingModels": "一致するモデルがありません",
         "loading": "読み込み中",
+        "noMatchingLoRAs": "一致するLoRAがありません",
         "noModelsAvailable": "使用可能なモデルがありません",
         "selectModel": "モデルを選択してください",
         "concepts": "コンセプト",
         "addLora": "LoRAを追加",
         "lora": "LoRA",
         "defaultVAE": "デフォルトVAE",
+        "noLoRAsInstalled": "インストールされているLoRAはありません",
         "noRefinerModelsInstalled": "インストールされているSDXLリファイナーモデルはありません",
         "noCompatibleLoRAs": "互換性のあるLoRAはありません"
     },
@@ -1025,6 +1074,7 @@
         "addNodeToolTip": "ノードを追加 (Shift+A, Space)",
         "missingTemplate": "Invalid node: タイプ {{type}} のノード {{node}} にテンプレートがありません（未インストール？）",
         "loadWorkflow": "ワークフローを読み込み",
+        "hideLegendNodes": "フィールドタイプの凡例を非表示",
         "float": "浮動小数点",
         "integer": "整数",
         "nodeTemplate": "ノードテンプレート",
@@ -1068,11 +1118,13 @@
         "enum": "Enum",
         "arithmeticSequence": "等差数列",
         "linearDistribution": "線形分布",
+        "addLinearView": "ライナービューに追加",
         "animatedEdges": "アニメーションエッジ",
         "uniformRandomDistribution": "一様ランダム分布",
         "noBatchGroup": "グループなし",
         "parseString": "文字列の解析",
         "generatorImagesFromBoard": "ボードからの画像",
+        "generatorLoading": "読み込み中",
         "missingNode": "呼び出しノードがありません",
         "missingSourceOrTargetNode": "ソースまたはターゲットノードがありません",
         "missingSourceOrTargetHandle": "ソースまたはターゲットハンドルがありません",
@@ -1093,6 +1145,7 @@
         "missingInvocationTemplate": "呼び出しテンプレートがありません",
         "nodePack": "ノードパック",
         "targetNodeFieldDoesNotExist": "無効なエッジ:ターゲット/インプットフィールド{{node}}.{{field}} が存在しません",
+        "mismatchedVersion": "無効なノード:ノード {{node}} のタイプ {{type}} はバージョンとミスマッチしています (アップデートを試されますか?)",
         "dynamicPromptsCombinatorial": "ダイナミックプロンプト(組み合わせ)",
         "cannotMixAndMatchCollectionItemTypes": "コレクション・アイテムの種類を組み合わせることはできません",
         "missingFieldTemplate": "フィールドテンプレートがありません",
@@ -1102,6 +1155,7 @@
         "collectionOrScalarFieldType": "{{name}} (単数またはコレクション)",
         "unableToUpdateNode": "ノードアップロード失敗:ノード {{node}} のタイプ {{type}} (削除か再生成が必要かもしれません)",
         "deletedInvalidEdge": "無効なエッジを削除しました{{source}} -> {{target}}",
+        "noFieldsLinearview": "線形ビューに追加されたフィールドがありません",
         "collectionFieldType": "{{name}} (コレクション)",
         "colorCodeEdgesHelp": "接続されたフィールドによるカラーコードエッジ",
         "showEdgeLabelsHelp": "エッジのラベルを表示，接続されているノードを示す",
@@ -1116,6 +1170,7 @@
         "loadWorkflowDesc2": "現在のワークフローは保存されていない変更があります.",
         "clearWorkflowDesc": "このワークフローをクリアして新しいワークフローにしますか？",
         "updateNode": "ノードをアップデート",
+        "versionUnknown": " バージョン不明",
         "graph": "グラフ",
         "workflowContact": "お問い合わせ",
         "outputFieldTypeParseError": "出力フィールド {{node}}.{{field}} の型を解析できません({{message}})",
@@ -1134,28 +1189,36 @@
         "unableToExtractSchemaNameFromRef": "参照からスキーマ名を抽出できません",
         "unableToUpdateNodes_other": "{{count}} 個のノードをアップデートできません",
         "workflowSettings": "ワークフローエディター設定",
+        "generateValues": "値を生成",
+        "floatRangeGenerator": "浮動小数点レンジ生成器",
+        "integerRangeGenerator": "整数レンジ生成器",
         "specialDesc": "この呼び出しは,アプリ内で特別な処理を行います.例えば,バッチノードは1つのワークフローから複数のグラフをキューに入れるために使用されます.",
         "modelAccessError": "モデル {{key}}が見つからないので,デフォルトにリセットします",
         "betaDesc": "この呼び出しはベータ版です.安定するまでは,アプリのアップデートの際に変更される可能性があります.この呼び出しは長期的にサポートする予定です.",
         "internalDesc": "この呼び出しはInvokeによって内部的に使用されます.アプリの更新時に変更される可能性があり,いつでも削除される可能性があります.",
         "noFieldsViewMode": "このワークフローには表示する選択フィールドがありません.値を設定するためにはワークフロー全体を表示します.",
         "clearWorkflow": "ワークフローをクリア",
+        "removeLinearView": "線形ビューから削除",
         "snapToGrid": "グリッドにスナップ",
         "showMinimapnodes": "ミニマップを表示",
+        "reorderLinearView": "線形ビューの並び替え",
         "description": "説明",
         "notesDescription": "ワークフローに関するメモを追加する",
         "newWorkflowDesc2": "現在のワークフローに保存されていない変更があります.",
         "unknownField": "不明なフィールド",
         "unexpectedField_withName": "予期しないフィールド\"{{name}}\"",
+        "loadingTemplates": "読み込み中 {{name}}",
         "validateConnectionsHelp": "無効な接続が行われたり,無効なグラフが呼び出されたりしないようにします",
         "validateConnections": "接続とグラフを確認する",
         "saveToGallery": "ギャラリーに保存",
         "newWorkflowDesc": "新しいワークフローを作りますか？",
         "unknownFieldType": "$t(nodes.unknownField)型: {{type}}",
         "unsupportedArrayItemType": "サポートされていない配列項目型です \"{{type}}\"",
+        "unableToLoadWorkflow": "ワークフローが読み込めません",
         "unableToValidateWorkflow": "ワークフローを確認できません",
         "unknownErrorValidatingWorkflow": "ワークフローの確認で不明なエラーが発生",
         "clearWorkflowDesc2": "現在のワークフローは保存されていない変更があります.",
+        "showLegendNodes": "フィールドタイプの凡例を表示",
         "unsupportedMismatchedUnion": "CollectionOrScalar型とベース型{{firstType}}および{{secondType}}が不一致です",
         "updateApp": "アプリケーションをアップデート",
         "noGraph": "グラフなし",
@@ -1173,8 +1236,10 @@
         "workflowDescription": "短い説明",
         "workflowValidation": "ワークフロー検証エラー",
         "noOutputRecorded": "記録されたアウトプットがありません",
+        "unknownTemplate": "不明なテンプレート",
         "nodeOpacity": "ノードの不透明度",
-        "unableToParseFieldType": "フィールドタイプを解析できません"
+        "unableToParseFieldType": "フィールドタイプを解析できません",
+        "unknownInput": "不明な入力: {{name}}"
     },
     "boards": {
         "autoAddBoard": "自動追加するボード",
@@ -1198,6 +1263,7 @@
         "deleteBoardOnly": "ボードのみ削除",
         "deletedBoardsCannotbeRestored": "削除したボードと画像は復元できません。「ボードのみ削除」を選択すると、画像は未分類の状態になります。",
         "movingImagesToBoard_other": "{{count}} の画像をボードに移動:",
+        "hideBoards": "ボードを隠す",
         "assetsWithCount_other": "{{count}} のアセット",
         "addPrivateBoard": "プライベートボードを追加",
         "addSharedBoard": "共有ボードを追加",
@@ -1212,8 +1278,10 @@
         "selectedForAutoAdd": "自動追加に選択済み",
         "deletedPrivateBoardsCannotbeRestored": "削除されたボードと画像は復元できません。「ボードのみ削除」を選択すると、画像は作成者に対して非公開の未分類状態になります。",
         "noBoards": "{{boardType}} ボードがありません",
+        "viewBoards": "ボードを表示",
         "uncategorizedImages": "分類されていない画像",
-        "deleteAllUncategorizedImages": "分類されていないすべての画像を削除"
+        "deleteAllUncategorizedImages": "分類されていないすべての画像を削除",
+        "deletedImagesCannotBeRestored": "削除した画像は復元できません."
     },
     "invocationCache": {
         "invocationCache": "呼び出しキャッシュ",
@@ -1685,7 +1753,9 @@
             "strength": "高解像修復の強度",
             "enabled": "高解像修復が有効"
         },
-        "hrf": "高解像修復"
+        "enableHrf": "高解像修復を有効",
+        "hrf": "高解像修復",
+        "upscaleMethod": "アップスケール手法"
     },
     "prompt": {
         "addPromptTrigger": "プロンプトトリガーを追加",
@@ -1695,7 +1765,10 @@
         "expandCurrentPrompt": "現在のプロンプトを展開",
         "uploadImageForPromptGeneration": "プロンプト生成用の画像をアップロードする",
         "expandingPrompt": "プロンプトを展開しています...",
+        "resultTitle": "プロンプト拡張完了",
+        "resultSubtitle": "拡張プロンプトの処理方法を選択します:",
         "replace": "交換する",
+        "insert": "挿入する",
         "discard": "破棄する"
     },
     "ui": {
@@ -1761,9 +1834,11 @@
         }
     },
     "controlLayers": {
+        "globalReferenceImage_withCount_other": "全域参照画像",
         "regionalReferenceImage": "領域参照画像",
         "saveLayerToAssets": "レイヤーをアセットに保存",
         "global": "全域",
+        "inpaintMasks_withCount_hidden": "インペイントマスク ({{count}} hidden)",
         "opacity": "透明度",
         "canvasContextMenu": {
             "newRegionalGuidance": "新規領域ガイダンス",
@@ -1815,6 +1890,7 @@
         "duplicate": "複製",
         "addLayer": "レイヤーを追加",
         "rasterLayer": "ラスターレイヤー",
+        "inpaintMasks_withCount_visible": "({{count}}) インペイントマスク",
         "regional": "領域",
         "rectangle": "矩形",
         "moveBackward": "背面へ移動",
@@ -2016,6 +2092,7 @@
         "autoNegative": "オートネガティブ",
         "enableAutoNegative": "オートネガティブを有効にする",
         "disableAutoNegative": "オートネガティブを無効にする",
+        "deletePrompt": "プロンプトを削除",
         "deleteReferenceImage": "参照画像を削除",
         "showHUD": "HUDを表示",
         "maskFill": "マスク塗りつぶし",
@@ -2027,22 +2104,41 @@
         "addControlLayer": "$t(controlLayers.controlLayer)を追加します",
         "addInpaintMask": "$t(controlLayers.inpaintMask)を追加します",
         "addRegionalGuidance": "$t(controlLayers.regionalGuidance)を追加します",
+        "addGlobalReferenceImage": "$t(controlLayers.globalReferenceImage)を追加します",
         "addDenoiseLimit": "$t(controlLayers.denoiseLimit)を追加します",
         "controlLayer": "コントロールレイヤー",
         "inpaintMask": "インペイントマスク",
         "referenceImageRegional": "参考画像（地域別）",
+        "referenceImageGlobal": "参考画像（グローバル）",
         "asRasterLayer": "$t(controlLayers.rasterLayer) として",
         "asRasterLayerResize": "$t(controlLayers.rasterLayer) として (リサイズ)",
         "asControlLayer": "$t(controlLayers.controlLayer) として",
         "asControlLayerResize": "$t(controlLayers.controlLayer) として (リサイズ)",
         "referenceImage": "参照画像",
+        "sendingToCanvas": "キャンバスに生成をのせる",
+        "sendingToGallery": "生成をギャラリーに送る",
+        "sendToGallery": "ギャラリーに送る",
+        "sendToGalleryDesc": "Invokeを押すとユニークな画像が生成され、ギャラリーに保存されます。",
         "sendToCanvas": "キャンバスに送る",
         "newLayerFromImage": "画像から新規レイヤー",
         "newCanvasFromImage": "画像から新規キャンバス",
+        "newImg2ImgCanvasFromImage": "画像からの新規 Img2Img",
         "copyToClipboard": "クリップボードにコピー",
+        "sendToCanvasDesc": "Invokeを押すと、進行中の作品がキャンバス上にステージされます。",
+        "viewProgressInViewer": "<Btn>画像ビューア</Btn>で進行状況と出力を表示します。",
+        "viewProgressOnCanvas": "<Btn>キャンバス</Btn> で進行状況とステージ出力を表示します。",
         "rasterLayer_withCount_other": "ラスターレイヤー",
         "controlLayer_withCount_other": "コントロールレイヤー",
+        "regionalGuidance_withCount_hidden": "地域ガイダンス（{{count}} 件非表示）",
+        "controlLayers_withCount_hidden": "コントロールレイヤー（{{count}} 個非表示）",
+        "rasterLayers_withCount_hidden": "ラスター レイヤー ({{count}} 個非表示)",
+        "globalReferenceImages_withCount_hidden": "グローバル参照画像（{{count}} 枚非表示）",
+        "regionalGuidance_withCount_visible": "地域ガイダンス ({{count}})",
+        "controlLayers_withCount_visible": "コントロールレイヤー ({{count}})",
+        "rasterLayers_withCount_visible": "ラスターレイヤー（{{count}}）",
+        "globalReferenceImages_withCount_visible": "グローバル参照画像 ({{count}})",
         "layer_other": "レイヤー",
+        "layer_withCount_other": "レイヤー ({{count}})",
         "convertRasterLayerTo": "$t(controlLayers.rasterLayer) を変換する",
         "convertControlLayerTo": "$t(controlLayers.controlLayer) を変換する",
         "convertRegionalGuidanceTo": "$t(controlLayers.regionalGuidance) を変換する",
@@ -2060,6 +2156,7 @@
         "pasteToBboxDesc": "新しいレイヤー（Bbox内）",
         "pasteToCanvas": "キャンバス",
         "pasteToCanvasDesc": "新しいレイヤー（キャンバス内）",
+        "pastedTo": "{{destination}} に貼り付けました",
         "transparency": "透明性",
         "enableTransparencyEffect": "透明効果を有効にする",
         "disableTransparencyEffect": "透明効果を無効にする",
@@ -2072,6 +2169,7 @@
         "locked": "ロックされています",
         "unlocked": "ロック解除",
         "deleteSelected": "選択項目を削除",
+        "stagingOnCanvas": "ステージング画像",
         "replaceLayer": "レイヤーの置き換え",
         "pullBboxIntoLayer": "Bboxをレイヤーに引き込む",
         "pullBboxIntoReferenceImage": "Bboxを参照画像に取り込む",
@@ -2079,11 +2177,17 @@
         "useImage": "画像を使う",
         "negativePrompt": "ネガティブプロンプト",
         "beginEndStepPercentShort": "開始/終了 %",
+        "newGallerySession": "新しいギャラリーセッション",
+        "newGallerySessionDesc": "これにより、キャンバスとモデル選択以外のすべての設定がクリアされます。生成した画像はギャラリーに送信されます。",
+        "newCanvasSession": "新規キャンバスセッション",
+        "newCanvasSessionDesc": "これにより、キャンバスとモデル選択以外のすべての設定がクリアされます。生成はキャンバス上でステージングされます。",
         "resetCanvasLayers": "キャンバスレイヤーをリセット",
         "resetGenerationSettings": "生成設定をリセット",
+        "replaceCurrent": "現在のものを置き換える",
         "controlLayerEmptyState": "<UploadButton>画像をアップロード</UploadButton>、<GalleryButton>ギャラリー</GalleryButton>からこのレイヤーに画像をドラッグ、<PullBboxButton>境界ボックスをこのレイヤーにプル</PullBboxButton>、またはキャンバスに描画して開始します。",
         "referenceImageEmptyStateWithCanvasOptions": "開始するには、<UploadButton>画像をアップロード</UploadButton>するか、<GalleryButton>ギャラリー</GalleryButton>からこの参照画像に画像をドラッグするか、<PullBboxButton>境界ボックスをこの参照画像にプル</PullBboxButton>します。",
         "referenceImageEmptyState": "開始するには、<UploadButton>画像をアップロード</UploadButton>するか、<GalleryButton>ギャラリー</GalleryButton>からこの参照画像に画像をドラッグします。",
+        "uploadOrDragAnImage": "ギャラリーから画像をドラッグするか、<UploadButton>画像をアップロード</UploadButton>します。",
         "imageNoise": "画像ノイズ",
         "denoiseLimit": "ノイズ除去制限",
         "warnings": {
@@ -2149,6 +2253,9 @@
             "saveAs": "名前を付けて保存",
             "cancel": "キャンセル",
             "process": "プロセス",
+            "help1": "ターゲットオブジェクトを1つ選択します。<Bold>含める</Bold>ポイントと<Bold>除外</Bold>ポイントを追加して、レイヤーのどの部分がターゲットオブジェクトの一部であるかを示します。",
+            "help2": "対象オブジェクト内に<Bold>含める</Bold>ポイントを1つ選択するところから始めます。ポイントを追加して選択範囲を絞り込みます。ポイントが少ないほど、通常はより良い結果が得られます。",
+            "help3": "選択を反転して、ターゲットオブジェクト以外のすべてを選択します。",
             "clickToAdd": "レイヤーをクリックしてポイントを追加します",
             "dragToMove": "ポイントをドラッグして移動します",
             "clickToRemove": "ポイントをクリックして削除します"
@@ -2249,8 +2356,12 @@
         "loading": "ロード中...",
         "steps": "ステップ",
         "refiner": "Refiner",
+        "negStylePrompt": "ネガティブスタイルプロンプト",
         "noModelsAvailable": "利用できるモデルがありません",
+        "posStylePrompt": "ポジティブスタイルプロンプト",
         "cfgScale": "CFGスケール",
+        "concatPromptStyle": "リンキングプロンプトとスタイル",
+        "freePromptStyle": "手動スタイルプロンプト",
         "posAestheticScore": "ポジティブ美的スコア",
         "refinerSteps": "リファイナーステップ",
         "refinerStart": "リファイナースタート",
@@ -2268,6 +2379,8 @@
         "name": "名前",
         "descending": "降順",
         "searchPlaceholder": "名前、説明、タグで検索",
+        "projectWorkflows": "プロジェクトワークフロー",
+        "searchWorkflows": "ワークフローを検索",
         "updated": "アップデート",
         "published": "公表",
         "builder": {
@@ -2293,8 +2406,10 @@
             "addToForm": "フォームに追加",
             "headingPlaceholder": "空の見出し",
             "nodeFieldTooltip": "ノード フィールドを追加するには、ワークフロー エディターのフィールドにある小さなプラス記号ボタンをクリックするか、フィールド名をフォームにドラッグします。",
+            "workflowBuilderAlphaWarning": "ワークフロービルダーは現在アルファ版です。安定版リリースまでに互換性に影響する変更が発生する可能性があります。",
             "component": "コンポーネント",
             "textPlaceholder": "空のテキスト",
+            "emptyRootPlaceholderViewMode": "このワークフローのフォームの作成を開始するには、[編集] をクリックします。",
             "addOption": "オプションを追加",
             "singleLine": "単線",
             "numberInput": "数値入力",
@@ -2345,15 +2460,20 @@
         "convertGraph": "グラフを変換",
         "downloadWorkflow": "ファイルに保存",
         "saveWorkflow": "ワークフローを保存",
+        "userWorkflows": "ユーザーワークフロー",
         "yourWorkflows": "あなたのワークフロー",
         "edit": "編集",
         "workflowLibrary": "ワークフローライブラリ",
         "workflowSaved": "ワークフローが保存されました",
+        "clearWorkflowSearchFilter": "ワークフロー検索フィルタをクリア",
         "workflowCleared": "ワークフローが作成されました",
         "autoLayout": "オートレイアウト",
         "view": "ビュー",
         "saveChanges": "変更を保存",
+        "noDescription": "説明なし",
         "recommended": "あなたへのおすすめ",
+        "noRecentWorkflows": "最近のワークフローがありません",
+        "problemLoading": "ワークフローのローディングに関する問題",
         "newWorkflowCreated": "新しいワークフローが作成されました",
         "noWorkflows": "ワークフローがありません",
         "copyShareLink": "共有リンクをコピー",
@@ -2361,16 +2481,21 @@
         "workflowThumbnail": "ワークフローサムネイル",
         "loadWorkflow": "$t(common.load) ワークフロー",
         "shared": "共有",
+        "openWorkflow": "ワークフローを開く",
         "emptyStringPlaceholder": "<空の文字列>",
         "browseWorkflows": "ワークフローを閲覧する",
         "saveWorkflowAs": "ワークフローとして保存",
         "private": "プライベート",
         "deselectAll": "すべて選択解除",
         "delete": "削除",
+        "openLibrary": "ライブラリを開く",
         "loadMore": "もっと読み込む",
         "saveWorkflowToProject": "ワークフローをプロジェクトに保存",
         "created": "作成されました",
         "workflowEditorMenu": "ワークフローエディターメニュー",
+        "defaultWorkflows": "デフォルトワークフロー",
+        "allLoaded": "すべてのワークフローが読み込まれました",
+        "filterByTags": "タグでフィルター",
         "recentlyOpened": "最近開いた",
         "opened": "オープン",
         "deleteWorkflow": "ワークフローを削除",
@@ -2416,6 +2541,7 @@
             "perIterationDesc": "それぞれのいてレーションに別のシードを使う"
         },
         "showDynamicPrompts": "ダイナミックプロンプトを表示する",
+        "promptsToGenerate": "生成するプロンプト",
         "dynamicPrompts": "ダイナミックプロンプト",
         "loading": "ダイナミックプロンプトを生成...",
         "maxPrompts": "最大プロンプト"
@@ -2441,7 +2567,8 @@
             "キャンバス: SDXL のアスペクト比がスマートになり、スクロールによるズームが改善されました。"
         ],
         "readReleaseNotes": "リリースノートを読む",
-        "watchRecentReleaseVideos": "最近のリリースビデオを見る"
+        "watchRecentReleaseVideos": "最近のリリースビデオを見る",
+        "watchUiUpdatesOverview": "Watch UI アップデートの概要"
     },
     "supportVideos": {
         "supportVideos": "サポートビデオ",

invokeai/frontend/web/public/locales/ko.json

@@ -27,6 +27,7 @@
         "save": "저장",
         "created": "생성됨",
         "error": "에러",
+        "prevPage": "이전 페이지",
         "ipAdapter": "IP 어댑터",
         "installed": "설치됨",
         "accept": "수락",
@@ -41,6 +42,7 @@
         "outputs": "결과물",
         "unknownError": "알려지지 않은 에러",
         "linear": "선형",
+        "imageFailedToLoad": "이미지를 로드할 수 없음",
         "direction": "방향",
         "data": "데이터",
         "somethingWentWrong": "뭔가 잘못됐어요",
@@ -50,6 +52,7 @@
         "orderBy": "정렬 기준",
         "copyError": "$t(gallery.copy) 에러",
         "learnMore": "더 알아보기",
+        "nextPage": "다음 페이지",
         "saveAs": "다른 이름으로 저장",
         "loading": "불러오는 중",
         "random": "랜덤",
@@ -57,15 +60,18 @@
         "postprocessing": "후처리",
         "advanced": "고급",
         "input": "입력",
-        "details": "세부사항"
+        "details": "세부사항",
+        "notInstalled": "설치되지 않음"
     },
     "gallery": {
         "galleryImageSize": "이미지 크기",
         "gallerySettings": "갤러리 설정",
         "deleteSelection": "선택 항목 삭제",
         "featuresWillReset": "이 이미지를 삭제하면 해당 기능이 즉시 재설정됩니다.",
+        "noImagesInGallery": "보여줄 이미지가 없음",
         "autoSwitchNewImages": "새로운 이미지로 자동 전환",
         "loading": "불러오는 중",
+        "unableToLoad": "갤러리를 로드할 수 없음",
         "image": "이미지",
         "drop": "드랍",
         "downloadSelection": "선택 항목 다운로드",
@@ -145,6 +151,8 @@
         "loadWorkflow": "Workflow 불러오기",
         "noOutputRecorded": "기록된 출력 없음",
         "colorCodeEdgesHelp": "연결된 필드에 따른 색상 코드 선",
+        "hideLegendNodes": "필드 유형 범례 숨기기",
+        "addLinearView": "Linear View에 추가",
         "float": "실수",
         "targetNodeFieldDoesNotExist": "잘못된 모서리: 대상/입력 필드 {{node}}. {{field}}이(가) 없습니다",
         "animatedEdges": "애니메이션 모서리",
@@ -152,6 +160,7 @@
         "nodeTemplate": "노드 템플릿",
         "nodeOpacity": "노드 불투명도",
         "sourceNodeDoesNotExist": "잘못된 모서리: 소스/출력 노드 {{node}}이(가) 없습니다",
+        "noFieldsLinearview": "Linear View에 추가된 필드 없음",
         "nodeSearch": "노드 검색",
         "inputMayOnlyHaveOneConnection": "입력에 하나의 연결만 있을 수 있습니다",
         "notes": "메모",
@@ -186,6 +195,7 @@
         "notesDescription": "Workflow에 대한 메모 추가",
         "colorCodeEdges": "색상-코드 선",
         "targetNodeDoesNotExist": "잘못된 모서리: 대상/입력 노드 {{node}}이(가) 없습니다",
+        "mismatchedVersion": "잘못된 노드: {{type}} 유형의 {{node}} 노드에 일치하지 않는 버전이 있습니다(업데이트 해보시겠습니까?)",
         "addNodeToolTip": "노드 추가(Shift+A, Space)",
         "collectionOrScalarFieldType": "{{name}} 컬렉션|Scalar",
         "nodeVersion": "노드 버전",
@@ -232,6 +242,7 @@
         "next": "다음",
         "cancelBatch": "Batch 취소",
         "back": "back",
+        "batchFieldValues": "Batch 필드 값들",
         "cancel": "취소",
         "session": "세션",
         "time": "시간",
@@ -285,6 +296,8 @@
         "cacheSize": "캐시 크기"
     },
     "hrf": {
+        "enableHrf": "이용 가능한 고해상도 고정",
+        "upscaleMethod": "업스케일 방법",
         "metadata": {
             "strength": "고해상도 고정 강도",
             "enabled": "고해상도 고정 사용",
@@ -295,10 +308,12 @@
     "models": {
         "noMatchingModels": "일치하는 모델 없음",
         "loading": "로딩중",
+        "noMatchingLoRAs": "일치하는 LoRA 없음",
         "noModelsAvailable": "사용 가능한 모델이 없음",
         "addLora": "LoRA 추가",
         "selectModel": "모델 선택",
-        "noRefinerModelsInstalled": "SDXL Refiner 모델이 설치되지 않음"
+        "noRefinerModelsInstalled": "SDXL Refiner 모델이 설치되지 않음",
+        "noLoRAsInstalled": "설치된 LoRA 없음"
     },
     "boards": {
         "autoAddBoard": "자동 추가 Board",

invokeai/frontend/web/public/locales/nl.json

@@ -30,10 +30,12 @@
         "ipAdapter": "IP-adapter",
         "auto": "Autom.",
         "controlNet": "ControlNet",
+        "imageFailedToLoad": "Kan afbeelding niet laden",
         "learnMore": "Meer informatie",
         "advanced": "Uitgebreid",
         "file": "Bestand",
         "installed": "Geïnstalleerd",
+        "notInstalled": "Niet $t(common.installed)",
         "simple": "Eenvoudig",
         "somethingWentWrong": "Er ging iets mis",
         "add": "Voeg toe",
@@ -41,12 +43,14 @@
         "details": "Details",
         "outputs": "Uitvoeren",
         "save": "Bewaar",
+        "nextPage": "Volgende pagina",
         "blue": "Blauw",
         "alpha": "Alfa",
         "red": "Rood",
         "editor": "Editor",
         "folder": "Map",
         "format": "structuur",
+        "goTo": "Ga naar",
         "template": "Sjabloon",
         "input": "Invoer",
         "safetensors": "Safetensors",
@@ -58,6 +62,7 @@
         "negativePrompt": "Negatieve prompt",
         "selected": "Geselecteerd",
         "orderBy": "Sorteer op",
+        "prevPage": "Vorige pagina",
         "beta": "Bèta",
         "copyError": "$t(gallery.copy) Fout",
         "toResolve": "Op te lossen",
@@ -74,18 +79,21 @@
         "delete": "Verwijder",
         "direction": "Richting",
         "error": "Fout",
+        "localSystem": "Lokaal systeem",
         "unknownError": "Onbekende fout"
     },
     "gallery": {
         "galleryImageSize": "Afbeeldingsgrootte",
         "gallerySettings": "Instellingen galerij",
         "autoSwitchNewImages": "Wissel autom. naar nieuwe afbeeldingen",
+        "noImagesInGallery": "Geen afbeeldingen om te tonen",
         "deleteImage_one": "Verwijder afbeelding",
         "deleteImage_other": "",
         "deleteImagePermanent": "Verwijderde afbeeldingen kunnen niet worden hersteld.",
         "autoAssignBoardOnClick": "Ken automatisch bord toe bij klikken",
         "featuresWillReset": "Als je deze afbeelding verwijdert, dan worden deze functies onmiddellijk teruggezet.",
         "loading": "Bezig met laden",
+        "unableToLoad": "Kan galerij niet laden",
         "downloadSelection": "Download selectie",
         "currentlyInUse": "Deze afbeelding is momenteel in gebruik door de volgende functies:",
         "copy": "Kopieer",
@@ -191,10 +199,12 @@
         "scaledHeight": "Geschaalde H",
         "infillMethod": "Infill-methode",
         "tileSize": "Grootte tegel",
+        "downloadImage": "Download afbeelding",
         "usePrompt": "Hergebruik invoertekst",
         "useSeed": "Hergebruik seed",
         "useAll": "Hergebruik alles",
         "info": "Info",
+        "showOptionsPanel": "Toon deelscherm Opties (O of T)",
         "symmetry": "Symmetrie",
         "cancel": {
             "cancel": "Annuleer"
@@ -283,12 +293,15 @@
         "baseModelChangedCleared_one": "Basismodel is gewijzigd: {{count}} niet-compatibel submodel weggehaald of uitgeschakeld",
         "baseModelChangedCleared_other": "Basismodel is gewijzigd: {{count}} niet-compatibele submodellen weggehaald of uitgeschakeld",
         "loadedWithWarnings": "Werkstroom geladen met waarschuwingen",
+        "setControlImage": "Ingesteld als controle-afbeelding",
+        "setNodeField": "Ingesteld als knooppuntveld",
         "imageUploaded": "Afbeelding geüpload",
         "addedToBoard": "Toegevoegd aan bord",
         "workflowLoaded": "Werkstroom geladen",
         "modelAddedSimple": "Model toegevoegd aan wachtrij",
         "imageUploadFailed": "Fout bij uploaden afbeelding",
         "workflowDeleted": "Werkstroom verwijderd",
+        "invalidUpload": "Ongeldige upload",
         "problemRetrievingWorkflow": "Fout bij ophalen van werkstroom",
         "parameters": "Parameters",
         "modelImportCanceled": "Importeren model geannuleerd",
@@ -312,14 +325,17 @@
         "zoomOutNodes": "Uitzoomen",
         "fitViewportNodes": "Aanpassen aan beeld",
         "hideMinimapnodes": "Minimap verbergen",
+        "showLegendNodes": "Typelegende veld tonen",
         "zoomInNodes": "Inzoomen",
         "showMinimapnodes": "Minimap tonen",
+        "hideLegendNodes": "Typelegende veld verbergen",
         "reloadNodeTemplates": "Herlaad knooppuntsjablonen",
         "loadWorkflow": "Laad werkstroom",
         "downloadWorkflow": "Download JSON van werkstroom",
         "scheduler": "Planner",
         "missingTemplate": "Ongeldig knooppunt: knooppunt {{node}} van het soort {{type}} heeft een ontbrekend sjabloon (niet geïnstalleerd?)",
         "workflowDescription": "Korte beschrijving",
+        "versionUnknown": " Versie onbekend",
         "noNodeSelected": "Geen knooppunt gekozen",
         "addNode": "Voeg knooppunt toe",
         "unableToValidateWorkflow": "Kan werkstroom niet valideren",
@@ -333,7 +349,9 @@
         "integer": "Geheel getal",
         "nodeTemplate": "Sjabloon knooppunt",
         "nodeOpacity": "Dekking knooppunt",
+        "unableToLoadWorkflow": "Fout bij laden werkstroom",
         "snapToGrid": "Lijn uit op raster",
+        "noFieldsLinearview": "Geen velden toegevoegd aan lineaire weergave",
         "nodeSearch": "Zoek naar knooppunten",
         "updateNode": "Werk knooppunt bij",
         "version": "Versie",
@@ -352,7 +370,9 @@
         "edge": "Rand",
         "animatedEdgesHelp": "Animeer gekozen randen en randen verbonden met de gekozen knooppunten",
         "cannotDuplicateConnection": "Kan geen dubbele verbindingen maken",
+        "unknownTemplate": "Onbekend sjabloon",
         "noWorkflow": "Geen werkstroom",
+        "removeLinearView": "Verwijder uit lineaire weergave",
         "workflowTags": "Labels",
         "fullyContainNodesHelp": "Knooppunten moeten zich volledig binnen het keuzevak bevinden om te worden gekozen",
         "workflowValidation": "Validatiefout werkstroom",
@@ -377,11 +397,14 @@
         "unknownField": "Onbekend veld",
         "colorCodeEdges": "Kleurgecodeerde randen",
         "unknownNode": "Onbekend knooppunt",
+        "mismatchedVersion": "Ongeldig knooppunt: knooppunt {{node}} van het soort {{type}} heeft een niet-overeenkomende versie (probeer het bij te werken?)",
         "addNodeToolTip": "Voeg knooppunt toe (Shift+A, spatie)",
         "loadingNodes": "Bezig met laden van knooppunten...",
         "snapToGridHelp": "Lijn knooppunten uit op raster bij verplaatsing",
         "workflowSettings": "Instellingen werkstroomeditor",
+        "addLinearView": "Voeg toe aan lineaire weergave",
         "nodePack": "Knooppuntpakket",
+        "unknownInput": "Onbekende invoer: {{name}}",
         "sourceNodeFieldDoesNotExist": "Ongeldige rand: bron-/uitvoerveld {{node}}.{{field}} bestaat niet",
         "collectionFieldType": "Verzameling {{name}}",
         "deletedInvalidEdge": "Ongeldige hoek {{source}} -> {{target}} verwijderd",
@@ -396,6 +419,7 @@
         "sourceNodeDoesNotExist": "Ongeldige rand: bron-/uitvoerknooppunt {{node}} bestaat niet",
         "unsupportedArrayItemType": "niet-ondersteunde soort van het array-onderdeel \"{{type}}\"",
         "targetNodeFieldDoesNotExist": "Ongeldige rand: doel-/invoerveld {{node}}.{{field}} bestaat niet",
+        "reorderLinearView": "Herorden lineaire weergave",
         "newWorkflowDesc": "Een nieuwe werkstroom aanmaken?",
         "collectionOrScalarFieldType": "Verzameling|scalair {{name}}",
         "newWorkflow": "Nieuwe werkstroom",
@@ -710,21 +734,27 @@
         "refinerStart": "Startwaarde verfijning",
         "scheduler": "Planner",
         "cfgScale": "CFG-schaal",
+        "negStylePrompt": "Negatieve-stijlprompt",
         "noModelsAvailable": "Geen modellen beschikbaar",
         "refiner": "Verfijning",
         "negAestheticScore": "Negatieve esthetische score",
         "denoisingStrength": "Sterkte ontruising",
         "refinermodel": "Verfijningsmodel",
         "posAestheticScore": "Positieve esthetische score",
+        "concatPromptStyle": "Koppelen van prompt en stijl",
         "loading": "Bezig met laden...",
         "steps": "Stappen",
+        "posStylePrompt": "Positieve-stijlprompt",
+        "freePromptStyle": "Handmatige stijlprompt",
         "refinerSteps": "Aantal stappen verfijner"
     },
     "models": {
         "noMatchingModels": "Geen overeenkomend modellen",
         "loading": "bezig met laden",
+        "noMatchingLoRAs": "Geen overeenkomende LoRA's",
         "noModelsAvailable": "Geen modellen beschikbaar",
         "selectModel": "Kies een model",
+        "noLoRAsInstalled": "Geen LoRA's geïnstalleerd",
         "noRefinerModelsInstalled": "Geen SDXL-verfijningsmodellen geïnstalleerd",
         "defaultVAE": "Standaard-VAE",
         "lora": "LoRA",
@@ -792,12 +822,14 @@
         }
     },
     "hrf": {
+        "upscaleMethod": "Opschaalmethode",
         "metadata": {
             "strength": "Sterkte oplossing voor hoge resolutie",
             "method": "Methode oplossing voor hoge resolutie",
             "enabled": "Oplossing voor hoge resolutie ingeschakeld"
         },
-        "hrf": "Oplossing voor hoge resolutie"
+        "hrf": "Oplossing voor hoge resolutie",
+        "enableHrf": "Schakel oplossing in voor hoge resolutie"
     },
     "prompt": {
         "addPromptTrigger": "Voeg prompttrigger toe",

invokeai/frontend/web/public/locales/pl.json

@@ -41,9 +41,11 @@
         "somethingWentWrong": "Coś poszło nie tak",
         "green": "Zielony",
         "red": "Czerwony",
+        "imageFailedToLoad": "Nie można załadować obrazu",
         "saveAs": "Zapisz jako",
         "outputs": "Wyjścia",
         "data": "Dane",
+        "localSystem": "System Lokalny",
         "t2iAdapter": "Adapter T2I",
         "selected": "Zaznaczone",
         "warnings": "Ostrzeżenia",
@@ -62,10 +64,12 @@
         "openInViewer": "Otwórz podgląd",
         "safetensors": "Bezpieczniki",
         "ok": "Ok",
+        "goTo": "Idź do",
         "loadingImage": "wczytywanie zdjęcia",
         "input": "Wejście",
         "view": "Podgląd",
         "learnMore": "Dowiedz się więcej",
+        "notInstalled": "Nie $t(common.installed)",
         "loadingModel": "Wczytywanie modelu",
         "postprocessing": "Przetwarzanie końcowe",
         "random": "Losowo",
@@ -79,8 +83,10 @@
         "delete": "Usuń",
         "template": "Szablon",
         "txt2img": "Tekst na obraz",
+        "prevPage": "Poprzednia strona",
         "file": "Plik",
         "toResolve": "Do rozwiązania",
+        "nextPage": "Następna strona",
         "unknownError": "Nieznany błąd",
         "placeholderSelectAModel": "Wybierz model",
         "new": "Nowy",
@@ -93,6 +99,7 @@
         "galleryImageSize": "Rozmiar obrazów",
         "gallerySettings": "Ustawienia galerii",
         "autoSwitchNewImages": "Przełączaj na nowe obrazy",
+        "noImagesInGallery": "Brak obrazów w galerii",
         "gallery": "Galeria",
         "alwaysShowImageSizeBadge": "Zawsze pokazuj odznakę wielkości obrazu",
         "assetsTab": "Pliki, które wrzuciłeś do użytku w twoich projektach.",
@@ -121,10 +128,12 @@
         "scaledHeight": "Sk. do wys.",
         "infillMethod": "Metoda wypełniania",
         "tileSize": "Rozmiar kafelka",
+        "downloadImage": "Pobierz obraz",
         "usePrompt": "Skopiuj sugestie",
         "useSeed": "Skopiuj inicjator",
         "useAll": "Skopiuj wszystko",
-        "info": "Informacje"
+        "info": "Informacje",
+        "showOptionsPanel": "Pokaż panel ustawień"
     },
     "settings": {
         "models": "Modele",
@@ -177,6 +186,8 @@
         "selectedForAutoAdd": "Wybrany do automatycznego dodania",
         "deleteBoard": "Usuń tablicę",
         "clearSearch": "Usuń historię",
+        "hideBoards": "Ukryj tablice",
+        "viewBoards": "Zobacz tablice",
         "addSharedBoard": "Dodaj udostępnioną tablicę",
         "boards": "Tablice",
         "addPrivateBoard": "Dodaj prywatną tablicę",
@@ -222,7 +233,8 @@
             "strength": "Moc poprawki wysokiej rozdzielczości",
             "method": "Metoda High Resolution Fix"
         },
-        "hrf": "Poprawka \"Wysoka rozdzielczość\""
+        "hrf": "Poprawka \"Wysoka rozdzielczość\"",
+        "enableHrf": "Włącz poprawkę wysokiej rozdzielczości"
     },
     "queue": {
         "cancelTooltip": "Anuluj aktualną pozycję",
@@ -284,6 +296,7 @@
         "completed": "Zakończono",
         "item": "Pozycja",
         "failed": "Niepowodzenie",
+        "batchFieldValues": "Masowe Wartości pól",
         "graphFailedToQueue": "NIe udało się dodać tabeli do kolejki",
         "workflows": "Przepływy pracy",
         "next": "Następny",

invokeai/frontend/web/public/locales/pt-BR.json

@@ -17,7 +17,8 @@
     "gallery": {
         "galleryImageSize": "Tamanho da Imagem",
         "gallerySettings": "Configurações de Galeria",
-        "autoSwitchNewImages": "Trocar para Novas Imagens Automaticamente"
+        "autoSwitchNewImages": "Trocar para Novas Imagens Automaticamente",
+        "noImagesInGallery": "Sem Imagens na Galeria"
     },
     "modelManager": {
         "modelManager": "Gerente de Modelo",
@@ -73,10 +74,12 @@
         "scaledHeight": "A Escalada",
         "infillMethod": "Método de Preenchimento",
         "tileSize": "Tamanho do Ladrilho",
+        "downloadImage": "Baixar Imagem",
         "usePrompt": "Usar Prompt",
         "useSeed": "Usar Seed",
         "useAll": "Usar Todos",
         "info": "Informações",
+        "showOptionsPanel": "Mostrar Painel de Opções",
         "symmetry": "Simetria",
         "copyImage": "Copiar imagem",
         "denoisingStrength": "A força de remoção de ruído",

invokeai/frontend/web/public/locales/pt.json

@@ -17,6 +17,7 @@
     "gallery": {
         "gallerySettings": "Configurações de Galeria",
         "autoSwitchNewImages": "Trocar para Novas Imagens Automaticamente",
+        "noImagesInGallery": "Sem Imagens na Galeria",
         "galleryImageSize": "Tamanho da Imagem"
     },
     "modelManager": {
@@ -68,6 +69,7 @@
         "tileSize": "Tamanho do Ladrilho",
         "symmetry": "Simetria",
         "usePrompt": "Usar Prompt",
+        "showOptionsPanel": "Mostrar Painel de Opções",
         "strength": "Força",
         "upscaling": "Redimensionando",
         "scaleBeforeProcessing": "Escala Antes do Processamento",
@@ -79,6 +81,7 @@
         "scaledHeight": "A Escalada",
         "infillMethod": "Método de Preenchimento",
         "copyImage": "Copiar imagem",
+        "downloadImage": "Descarregar Imagem",
         "useSeed": "Usar Seed",
         "useAll": "Usar Todos",
         "info": "Informações"

invokeai/frontend/web/public/locales/ru.json

@@ -38,6 +38,7 @@
         "save": "Сохранить",
         "created": "Создано",
         "error": "Ошибка",
+        "prevPage": "Предыдущая страница",
         "simple": "Простой",
         "ipAdapter": "IP Adapter",
         "installed": "Установлено",
@@ -48,6 +49,7 @@
         "template": "Шаблон",
         "outputs": "результаты",
         "unknownError": "Неизвестная ошибка",
+        "imageFailedToLoad": "Невозможно загрузить изображение",
         "direction": "Направление",
         "data": "Данные",
         "somethingWentWrong": "Что-то пошло не так",
@@ -56,9 +58,11 @@
         "orderBy": "Сортировать по",
         "copyError": "Ошибка $t(gallery.copy)",
         "learnMore": "Узнать больше",
+        "nextPage": "Следущая страница",
         "saveAs": "Сохранить как",
         "input": "Вход",
         "details": "Детали",
+        "notInstalled": "Нет $t(common.installed)",
         "or": "или",
         "aboutHeading": "Владей своей творческой силой",
         "red": "Красный",
@@ -67,6 +71,7 @@
         "alpha": "Альфа",
         "toResolve": "Чтоб решить",
         "copy": "Копировать",
+        "localSystem": "Локальная система",
         "aboutDesc": "Используя Invoke для работы? Проверьте это:",
         "add": "Добавить",
         "beta": "Бета",
@@ -74,6 +79,7 @@
         "positivePrompt": "Позитивный запрос",
         "negativePrompt": "Негативный запрос",
         "editor": "Редактор",
+        "goTo": "Перейти к",
         "tab": "Вкладка",
         "enabled": "Включено",
         "disabled": "Отключено",
@@ -95,6 +101,7 @@
         "galleryImageSize": "Размер изображений",
         "gallerySettings": "Настройка галереи",
         "autoSwitchNewImages": "Автоматически выбирать новые",
+        "noImagesInGallery": "Изображений нет",
         "deleteImagePermanent": "Удаленные изображения невозможно восстановить.",
         "deleteImage_one": "Удалить изображение",
         "deleteImage_few": "Удалить {{count}} изображения",
@@ -103,6 +110,7 @@
         "deleteSelection": "Удалить выделенное",
         "featuresWillReset": "Если вы удалите это изображение, эти функции будут немедленно сброшены.",
         "loading": "Загрузка",
+        "unableToLoad": "Невозможно загрузить галерею",
         "image": "изображение",
         "drop": "перебросить",
         "downloadSelection": "Скачать выделенное",
@@ -128,6 +136,7 @@
         "compareHelp4": "Нажмите <Kbd>Z</Kbd> или <Kbd>Esc</Kbd> для выхода.",
         "compareImage": "Сравнить изображение",
         "viewerImage": "Изображение просмотрщика",
+        "selectAnImageToCompare": "Выберите изображение для сравнения",
         "slider": "Слайдер",
         "sideBySide": "Бок о бок",
         "compareHelp1": "Удерживайте <Kbd>Alt</Kbd> при нажатии на изображение в галерее или при помощи клавиш со стрелками, чтобы изменить сравниваемое изображение.",
@@ -145,8 +154,11 @@
         "exitBoardSearch": "Выйти из поиска досок",
         "go": "Перейти",
         "exitSearch": "Выйти из поиска изображений",
+        "jump": "Пыгнуть",
         "move": "Двигать",
         "gallery": "Галерея",
+        "openViewer": "Открыть просмотрщик",
+        "closeViewer": "Закрыть просмотрщик",
         "imagesTab": "Изображения, созданные и сохраненные в Invoke.",
         "assetsTab": "Файлы, которые вы загрузили для использования в своих проектах.",
         "boardsSettings": "Настройки доски",
@@ -562,6 +574,8 @@
         "noModelsInstalled": "Нет установленных моделей",
         "noModelsInstalledDesc1": "Установите модели с помощью",
         "noMatchingModels": "Нет подходящих моделей",
+        "ipAdapters": "IP адаптеры",
+        "starterModelsInModelManager": "Стартовые модели можно найти в Менеджере моделей",
         "learnMoreAboutSupportedModels": "Подробнее о поддерживаемых моделях",
         "t5Encoder": "T5 энкодер",
         "spandrelImageToImage": "Image to Image (Spandrel)",
@@ -598,10 +612,12 @@
         "scaledHeight": "Масштаб В",
         "infillMethod": "Способ заполнения",
         "tileSize": "Размер области",
+        "downloadImage": "Скачать",
         "usePrompt": "Использовать запрос",
         "useSeed": "Использовать сид",
         "useAll": "Использовать все",
         "info": "Метаданные",
+        "showOptionsPanel": "Показать панель настроек",
         "cancel": {
             "cancel": "Отмена"
         },
@@ -627,6 +643,10 @@
             "missingFieldTemplate": "Отсутствует шаблон поля",
             "addingImagesTo": "Добавление изображений в",
             "invoke": "Создать",
+            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), ширина рамки {{width}}",
+            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), высота рамки {{height}}",
+            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), масштабированная высота рамки {{height}}",
+            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16) масштабированная ширина рамки {{width}}",
             "noFLUXVAEModelSelected": "Для генерации FLUX не выбрана модель VAE",
             "noT5EncoderModelSelected": "Для генерации FLUX не выбрана модель T5 энкодера",
             "canvasIsFiltering": "Холст фильтруется",
@@ -712,6 +732,9 @@
         "baseModelChangedCleared_few": "Очищено или отключено {{count}} несовместимых подмодели",
         "baseModelChangedCleared_many": "Очищено или отключено {{count}} несовместимых подмоделей",
         "loadedWithWarnings": "Рабочий процесс загружен с предупреждениями",
+        "setControlImage": "Установить как контрольное изображение",
+        "setNodeField": "Установить как поле узла",
+        "invalidUpload": "Неверная загрузка",
         "imageUploaded": "Изображение загружено",
         "addedToBoard": "Добавлено в активы доски {{name}}",
         "workflowLoaded": "Рабочий процесс загружен",
@@ -740,14 +763,21 @@
         "sentToCanvas": "Отправить на холст",
         "unableToLoadImage": "Невозможно загрузить изображение",
         "unableToLoadImageMetadata": "Невозможно загрузить метаданные изображения",
+        "imageSaved": "Изображение сохранено",
         "stylePresetLoaded": "Предустановка стиля загружена",
+        "imageNotLoadedDesc": "Не удалось найти изображение",
+        "imageSavingFailed": "Не удалось сохранить изображение",
         "problemCopyingLayer": "Не удалось скопировать слой",
         "unableToLoadStylePreset": "Невозможно загрузить предустановку стиля",
         "layerCopiedToClipboard": "Слой скопирован в буфер обмена",
         "sentToUpscale": "Отправить на увеличение",
+        "layerSavedToAssets": "Слой сохранен в активах",
         "linkCopied": "Ссылка скопирована",
         "addedToUncategorized": "Добавлено в активы доски $t(boards.uncategorized)",
-        "imagesWillBeAddedTo": "Загруженные изображения будут добавлены в активы доски {{boardName}}."
+        "imagesWillBeAddedTo": "Загруженные изображения будут добавлены в активы доски {{boardName}}.",
+        "uploadFailedInvalidUploadDesc_withCount_one": "Должно быть не более {{count}} изображения в формате PNG или JPEG.",
+        "uploadFailedInvalidUploadDesc_withCount_few": "Должно быть не более {{count}} изображений в формате PNG или JPEG.",
+        "uploadFailedInvalidUploadDesc_withCount_many": "Должно быть не более {{count}} изображений в формате PNG или JPEG."
     },
     "accessibility": {
         "uploadImage": "Загрузить изображение",
@@ -769,12 +799,15 @@
         "zoomInNodes": "Увеличьте масштаб",
         "zoomOutNodes": "Уменьшите масштаб",
         "fitViewportNodes": "Уместить вид",
+        "showLegendNodes": "Показать тип поля",
         "hideMinimapnodes": "Скрыть миникарту",
+        "hideLegendNodes": "Скрыть тип поля",
         "showMinimapnodes": "Показать миникарту",
         "loadWorkflow": "Загрузить рабочий процесс",
         "reloadNodeTemplates": "Перезагрузить шаблоны узлов",
         "downloadWorkflow": "Скачать JSON рабочего процесса",
         "addNode": "Добавить узел",
+        "addLinearView": "Добавить в линейный вид",
         "animatedEdges": "Анимированные ребра",
         "animatedEdgesHelp": "Анимация выбранных ребер и ребер, соединенных с выбранными узлами",
         "boolean": "Логические значения",
@@ -786,6 +819,7 @@
         "workflowDescription": "Краткое описание",
         "inputFieldTypeParseError": "Невозможно разобрать тип поля ввода {{node}}.{{field}} ({{message}})",
         "unsupportedAnyOfLength": "слишком много элементов объединения ({{count}})",
+        "versionUnknown": " Версия неизвестна",
         "unsupportedArrayItemType": "неподдерживаемый тип элемента массива \"{{type}}\"",
         "noNodeSelected": "Узел не выбран",
         "unableToValidateWorkflow": "Невозможно проверить рабочий процесс",
@@ -803,8 +837,10 @@
         "nodeTemplate": "Шаблон узла",
         "nodeOpacity": "Непрозрачность узла",
         "sourceNodeDoesNotExist": "Недопустимое ребро: исходный/выходной узел {{node}} не существует",
+        "unableToLoadWorkflow": "Невозможно загрузить рабочий процесс",
         "unableToExtractEnumOptions": "невозможно извлечь параметры перечисления",
         "snapToGrid": "Привязка к сетке",
+        "noFieldsLinearview": "Нет полей, добавленных в линейный вид",
         "unableToParseFieldType": "невозможно проанализировать тип поля",
         "nodeSearch": "Поиск узлов",
         "updateNode": "Обновить узел",
@@ -825,7 +861,9 @@
         "edge": "Край",
         "sourceNodeFieldDoesNotExist": "Неверный край: поле источника/вывода {{node}}.{{field}} не существует",
         "cannotDuplicateConnection": "Невозможно создать дубликаты соединений",
+        "unknownTemplate": "Неизвестный шаблон",
         "noWorkflow": "Нет рабочего процесса",
+        "removeLinearView": "Удалить из линейного вида",
         "workflowTags": "Теги",
         "fullyContainNodesHelp": "Чтобы узлы были выбраны, они должны полностью находиться в поле выбора",
         "unableToGetWorkflowVersion": "Не удалось получить версию схемы рабочего процесса",
@@ -858,6 +896,7 @@
         "colorCodeEdges": "Ребра с цветовой кодировкой",
         "unknownNode": "Неизвестный узел",
         "targetNodeDoesNotExist": "Недопустимое ребро: целевой/входной узел {{node}} не существует",
+        "mismatchedVersion": "Недопустимый узел: узел {{node}} типа {{type}} имеет несоответствующую версию (попробовать обновить?)",
         "unknownFieldType": "$t(nodes.unknownField) тип: {{type}}",
         "collectionOrScalarFieldType": "{{name}} (Один или коллекция)",
         "betaDesc": "Этот вызов находится в бета-версии. Пока он не станет стабильным, в нем могут происходить изменения при обновлении приложений. Мы планируем поддерживать этот вызов в течение длительного времени.",
@@ -866,12 +905,14 @@
         "snapToGridHelp": "Привязка узлов к сетке при перемещении",
         "workflowSettings": "Настройки редактора рабочих процессов",
         "deletedInvalidEdge": "Удалено недопустимое ребро {{source}} -> {{target}}",
+        "unknownInput": "Неизвестный вход: {{name}}",
         "newWorkflow": "Новый рабочий процесс",
         "newWorkflowDesc": "Создать новый рабочий процесс?",
         "clearWorkflow": "Очистить рабочий процесс",
         "newWorkflowDesc2": "Текущий рабочий процесс имеет несохраненные изменения.",
         "clearWorkflowDesc": "Очистить этот рабочий процесс и создать новый?",
         "clearWorkflowDesc2": "Текущий рабочий процесс имеет несохраненные измерения.",
+        "reorderLinearView": "Изменить порядок линейного просмотра",
         "viewMode": "Использовать в линейном представлении",
         "editMode": "Открыть в редакторе узлов",
         "resetToDefaultValue": "Сбросить к стандартному значкнию",
@@ -933,6 +974,8 @@
         "addPrivateBoard": "Добавить личную доску",
         "private": "Личные доски",
         "shared": "Общие доски",
+        "hideBoards": "Скрыть доски",
+        "viewBoards": "Просмотреть доски",
         "noBoards": "Нет досок {{boardType}}",
         "deletedPrivateBoardsCannotbeRestored": "Удаленные доски не могут быть восстановлены. Выбор «Удалить только доску» переведет изображения в приватное состояние без категории для создателя изображения.",
         "updateBoardError": "Ошибка обновления доски"
@@ -1361,6 +1404,8 @@
         "noRecallParameters": "Параметры для вызова не найдены",
         "cfgRescaleMultiplier": "$t(parameters.cfgRescaleMultiplier)",
         "parameterSet": "Параметр {{parameter}} установлен",
+        "parsingFailed": "Не удалось выполнить синтаксический анализ",
+        "recallParameter": "Отозвать {{label}}",
         "allPrompts": "Все запросы",
         "imageDimensions": "Размеры изображения",
         "canvasV2Metadata": "Холст",
@@ -1411,6 +1456,7 @@
         "next": "Следующий",
         "cancelBatch": "Отменить пакет",
         "back": "задний",
+        "batchFieldValues": "Пакетные значения полей",
         "cancel": "Отмена",
         "session": "Сессия",
         "time": "Время",
@@ -1445,14 +1491,18 @@
         "refinerStart": "Запуск доработчика",
         "scheduler": "Планировщик",
         "cfgScale": "Шкала точности (CFG)",
+        "negStylePrompt": "Негативный запрос стиля",
         "noModelsAvailable": "Нет доступных моделей",
         "refiner": "Доработчик",
         "negAestheticScore": "Отрицательная эстетическая оценка",
         "denoisingStrength": "Шумоподавление",
         "refinermodel": "Дорабатывающая модель",
         "posAestheticScore": "Положительная эстетическая оценка",
+        "concatPromptStyle": "Связывание запроса и стиля",
         "loading": "Загрузка...",
         "steps": "Шаги",
+        "posStylePrompt": "Запрос стиля",
+        "freePromptStyle": "Ручной запрос стиля",
         "refinerSteps": "Шаги доработчика"
     },
     "invocationCache": {
@@ -1477,15 +1527,20 @@
         "workflowEditorMenu": "Меню редактора рабочего процесса",
         "workflowName": "Имя рабочего процесса",
         "saveWorkflow": "Сохранить рабочий процесс",
+        "openWorkflow": "Открытый рабочий процесс",
+        "clearWorkflowSearchFilter": "Очистить фильтр поиска рабочих процессов",
         "workflowLibrary": "Библиотека",
         "downloadWorkflow": "Сохранить в файл",
         "workflowSaved": "Рабочий процесс сохранен",
         "unnamedWorkflow": "Безымянный рабочий процесс",
         "savingWorkflow": "Сохранение рабочего процесса...",
+        "problemLoading": "Проблема с загрузкой рабочих процессов",
         "loading": "Загрузка рабочих процессов",
+        "searchWorkflows": "Поиск рабочих процессов",
         "problemSavingWorkflow": "Проблема с сохранением рабочего процесса",
         "deleteWorkflow": "Удалить рабочий процесс",
         "workflows": "Рабочие процессы",
+        "noDescription": "Без описания",
         "uploadWorkflow": "Загрузить из файла",
         "newWorkflowCreated": "Создан новый рабочий процесс",
         "saveWorkflowToProject": "Сохранить рабочий процесс в проект",
@@ -1501,6 +1556,9 @@
         "convertGraph": "Конвертировать график",
         "loadFromGraph": "Загрузка рабочего процесса из графика",
         "autoLayout": "Автоматическое расположение",
+        "userWorkflows": "Пользовательские рабочие процессы",
+        "projectWorkflows": "Рабочие процессы проекта",
+        "defaultWorkflows": "Стандартные рабочие процессы",
         "deleteWorkflow2": "Вы уверены, что хотите удалить этот рабочий процесс? Это нельзя отменить.",
         "chooseWorkflowFromLibrary": "Выбрать рабочий процесс из библиотеки",
         "edit": "Редактировать",
@@ -1510,6 +1568,8 @@
         "delete": "Удалить"
     },
     "hrf": {
+        "enableHrf": "Включить исправление высокого разрешения",
+        "upscaleMethod": "Метод увеличения",
         "metadata": {
             "strength": "Сила исправления высокого разрешения",
             "enabled": "Исправление высокого разрешения включено",
@@ -1520,10 +1580,12 @@
     "models": {
         "noMatchingModels": "Нет подходящих моделей",
         "loading": "загрузка",
+        "noMatchingLoRAs": "Нет подходящих LoRA",
         "noModelsAvailable": "Нет доступных моделей",
         "addLora": "Добавить LoRA",
         "selectModel": "Выберите модель",
         "noRefinerModelsInstalled": "Дорабатывающие модели SDXL не установлены",
+        "noLoRAsInstalled": "Нет установленных LoRA",
         "lora": "LoRA",
         "defaultVAE": "Стандартное VAE",
         "concepts": "LoRA"
@@ -1558,6 +1620,7 @@
         "moveForward": "Переместить вперёд",
         "moveBackward": "Переместить назад",
         "autoNegative": "Авто негатив",
+        "deletePrompt": "Удалить запрос",
         "rectangle": "Прямоугольник",
         "addNegativePrompt": "Добавить $t(controlLayers.negativePrompt)",
         "regionalGuidance": "Региональная точность",
@@ -1727,6 +1790,7 @@
         },
         "addReferenceImage": "Добавить $t(controlLayers.referenceImage)",
         "inpaintMask": "Маска перерисовки",
+        "sendToGalleryDesc": "При нажатии кнопки Invoke создается изображение и сохраняется в вашей галерее.",
         "sendToCanvas": "Отправить на холст",
         "regionalGuidance_withCount_one": "$t(controlLayers.regionalGuidance)",
         "regionalGuidance_withCount_few": "Региональных точности",
@@ -1738,6 +1802,7 @@
         "inpaintMask_withCount_one": "$t(controlLayers.inpaintMask)",
         "inpaintMask_withCount_few": "Маски перерисовки",
         "inpaintMask_withCount_many": "Масок перерисовки",
+        "globalReferenceImages_withCount_visible": "Глобальные эталонные изображения ({{count}})",
         "controlMode": {
             "prompt": "Запрос",
             "controlMode": "Режим контроля",
@@ -1773,6 +1838,7 @@
         "pullBboxIntoReferenceImage": "Поместить рамку в эталонное изображение",
         "enableAutoNegative": "Включить авто негатив",
         "maskFill": "Заполнение маски",
+        "viewProgressInViewer": "Просматривайте прогресс и результаты в <Btn>Просмотрщике изображений</Btn>.",
         "tool": {
             "move": "Двигать",
             "bbox": "Ограничительная рамка",
@@ -1783,10 +1849,18 @@
             "colorPicker": "Подборщик цветов"
         },
         "rasterLayer": "Растровый слой",
+        "sendingToCanvas": "Постановка генераций на холст",
+        "rasterLayers_withCount_visible": "Растровые слои ({{count}})",
+        "regionalGuidance_withCount_hidden": "Региональная точность ({{count}} скрыто)",
         "enableTransparencyEffect": "Включить эффект прозрачности",
         "hidingType": "Скрыть {{type}}",
         "addRegionalGuidance": "Добавить $t(controlLayers.regionalGuidance)",
+        "sendingToGallery": "Отправка генераций в галерею",
+        "viewProgressOnCanvas": "Просматривайте прогресс и результаты этапов на <Btn>Холсте</Btn>.",
+        "controlLayers_withCount_hidden": "Контрольные слои ({{count}} скрыто)",
+        "rasterLayers_withCount_hidden": "Растровые слои ({{count}} скрыто)",
         "deleteSelected": "Удалить выбранное",
+        "stagingOnCanvas": "Постановка изображений на",
         "pullBboxIntoLayer": "Поместить рамку в слой",
         "locked": "Заблокировано",
         "replaceLayer": "Заменить слой",
@@ -1795,10 +1869,16 @@
         "addRasterLayer": "Добавить $t(controlLayers.rasterLayer)",
         "addControlLayer": "Добавить $t(controlLayers.controlLayer)",
         "addInpaintMask": "Добавить $t(controlLayers.inpaintMask)",
+        "inpaintMasks_withCount_hidden": "Маски перерисовки ({{count}} скрыто)",
+        "regionalGuidance_withCount_visible": "Региональная точность ({{count}})",
+        "newGallerySessionDesc": "Это очистит холст и все настройки, кроме выбранной модели. Генерации будут отправлены в галерею.",
+        "newCanvasSession": "Новая сессия холста",
+        "newCanvasSessionDesc": "Это очистит холст и все настройки, кроме выбора модели. Генерации будут размещены на холсте.",
         "cropLayerToBbox": "Обрезать слой по ограничительной рамке",
         "clipToBbox": "Обрезка штрихов в рамке",
         "outputOnlyMaskedRegions": "Вывод только маскированных областей",
         "duplicate": "Дублировать",
+        "inpaintMasks_withCount_visible": "Маски перерисовки ({{count}})",
         "layer_one": "Слой",
         "layer_few": "Слоя",
         "layer_many": "Слоев",
@@ -1817,20 +1897,33 @@
         },
         "disableAutoNegative": "Отключить авто негатив",
         "deleteReferenceImage": "Удалить эталонное изображение",
+        "controlLayers_withCount_visible": "Контрольные слои ({{count}})",
         "rasterLayer_withCount_one": "$t(controlLayers.rasterLayer)",
         "rasterLayer_withCount_few": "Растровых слоя",
         "rasterLayer_withCount_many": "Растровых слоев",
         "transparency": "Прозрачность",
         "weight": "Вес",
+        "newGallerySession": "Новая сессия галереи",
+        "sendToCanvasDesc": "Нажатие кнопки Invoke отображает вашу текущую работу на холсте.",
+        "globalReferenceImages_withCount_hidden": "Глобальные эталонные изображения ({{count}} скрыто)",
+        "layer_withCount_one": "Слой ({{count}})",
+        "layer_withCount_few": "Слои ({{count}})",
+        "layer_withCount_many": "Слои ({{count}})",
         "disableTransparencyEffect": "Отключить эффект прозрачности",
         "showingType": "Показать {{type}}",
         "dynamicGrid": "Динамическая сетка",
         "logDebugInfo": "Писать отладочную информацию",
         "unlocked": "Разблокировано",
         "showProgressOnCanvas": "Показать прогресс на холсте",
+        "globalReferenceImage_withCount_one": "$t(controlLayers.globalReferenceImage)",
+        "globalReferenceImage_withCount_few": "Глобальных эталонных изображения",
+        "globalReferenceImage_withCount_many": "Глобальных эталонных изображений",
         "regionalReferenceImage": "Региональное эталонное изображение",
         "globalReferenceImage": "Глобальное эталонное изображение",
-        "referenceImage": "Эталонное изображение"
+        "sendToGallery": "Отправить в галерею",
+        "referenceImage": "Эталонное изображение",
+        "addGlobalReferenceImage": "Добавить $t(controlLayers.globalReferenceImage)",
+        "newImg2ImgCanvasFromImage": "Новое img2img из изображения"
     },
     "ui": {
         "tabs": {

invokeai/frontend/web/public/locales/sv.json

@@ -28,6 +28,7 @@
     "gallery": {
         "galleryImageSize": "Bildstorlek",
         "gallerySettings": "Galleriinställningar",
+        "noImagesInGallery": "Inga bilder i galleriet",
         "autoSwitchNewImages": "Ändra automatiskt till nya bilder"
     }
 }

invokeai/frontend/web/public/locales/tr.json

@@ -36,10 +36,12 @@
         "communityLabel": "Topluluk",
         "back": "Geri",
         "areYouSure": "Emin misiniz?",
+        "notInstalled": "$t(common.installed) Değil",
         "openInNewTab": "Yeni Sekmede Aç",
         "aboutHeading": "Yaratıcı Gücünüzün Sahibi Olun",
         "load": "Yükle",
         "loading": "Yükleniyor",
+        "localSystem": "Yerel Sistem",
         "inpaint": "içboyama",
         "modelManager": "Model Yöneticisi",
         "orderBy": "Sırala",
@@ -63,8 +65,11 @@
         "format": "biçim",
         "details": "Ayrıntılar",
         "error": "Hata",
+        "imageFailedToLoad": "Görsel Yüklenemedi",
         "safetensors": "Safetensors",
         "upload": "Yükle",
+        "nextPage": "Sonraki Sayfa",
+        "prevPage": "Önceki Sayfa",
         "dontAskMeAgain": "Bir daha sorma",
         "delete": "Kaldır",
         "direction": "Yön",
@@ -176,6 +181,7 @@
         "session": "Oturum",
         "batchQueued": "Toplu İş Sıraya Alındı",
         "notReady": "Sıraya Alınamadı",
+        "batchFieldValues": "Toplu İş Değişkenleri",
         "graphFailedToQueue": "Çizge sıraya alınamadı",
         "graphQueued": "Çizge sıraya alındı"
     },
@@ -201,10 +207,12 @@
         "image": "görsel",
         "galleryImageSize": "Görsel Boyutu",
         "copy": "Kopyala",
+        "noImagesInGallery": "Gösterilecek Görsel Yok",
         "autoSwitchNewImages": "Yeni Görseli Biter Bitmez Gör",
         "currentlyInUse": "Bu görsel şurada kullanımda:",
         "deleteImage_one": "Görseli Sil",
         "deleteImage_other": "",
+        "unableToLoad": "Galeri Yüklenemedi",
         "downloadSelection": "Seçileni İndir",
         "dropOrUpload": "$t(gallery.drop) ya da Yükle",
         "dropToUpload": "Yüklemek için $t(gallery.drop)",
@@ -212,11 +220,13 @@
     },
     "hrf": {
         "hrf": "Yüksek Çözünürlük Kürü",
+        "enableHrf": "Yüksek Çözünürlük Kürünü Aç",
         "metadata": {
             "enabled": "Yüksek Çözünürlük Kürü Açık",
             "strength": "Yüksek Çözünürlük Kürü Etkisi",
             "method": "Yüksek Çözünürlük Kürü Yöntemi"
-        }
+        },
+        "upscaleMethod": "Büyütme Yöntemi"
     },
     "hotkeys": {
         "noHotkeysFound": "Kısayol Tuşu Bulanamadı",
@@ -246,6 +256,7 @@
         "unknownErrorValidatingWorkflow": "İş akışını doğrulamada bilinmeyen bir sorun",
         "unableToGetWorkflowVersion": "İş akışı sürümüne ulaşılamadı",
         "newWorkflowDesc2": "Geçerli iş akışında kaydedilmemiş değişiklikler var.",
+        "unableToLoadWorkflow": "İş Akışı Yüklenemedi",
         "cannotConnectInputToInput": "Giriş girişe bağlanamaz",
         "zoomInNodes": "Yakınlaştır",
         "boolean": "Boole Değeri",
@@ -256,12 +267,16 @@
         "cannotDuplicateConnection": "Kopya bağlantılar yaratılamaz"
     },
     "workflows": {
+        "searchWorkflows": "İş Akışlarında Ara",
         "workflowName": "İş Akışı Adı",
         "problemSavingWorkflow": "İş Akışını Kaydetmede Sorun",
         "saveWorkflow": "İş Akışını Kaydet",
         "uploadWorkflow": "Dosyadan Yükle",
         "newWorkflowCreated": "Yeni İş Akışı Yaratıldı",
+        "problemLoading": "İş Akışlarını Yüklemede Sorun",
         "loading": "İş Akışları Yükleniyor",
+        "noDescription": "Tanımsız",
+        "clearWorkflowSearchFilter": "İş Akışı Aramasını Resetle",
         "workflowEditorMenu": "İş Akışı Düzenleyici Menüsü",
         "downloadWorkflow": "İndir",
         "saveWorkflowAs": "İş Akışını Farklı Kaydet",
@@ -313,6 +328,7 @@
         "noiseThreshold": "Gürültü Eşiği",
         "seed": "Tohum",
         "imageActions": "Görsel İşlemleri",
+        "showOptionsPanel": "Yan Paneli Göster (O ya da T)",
         "shuffle": "Kar",
         "usePrompt": "İstemi Kullan",
         "setToOptimalSizeTooSmall": "$t(parameters.setToOptimalSize) (çok küçük olabilir)",
@@ -330,6 +346,7 @@
         "perlinNoise": "Perlin Gürültüsü",
         "scaledWidth": "Ölçekli En",
         "seamlessXAxis": "Dikişsiz Döşeme X Ekseni",
+        "downloadImage": "Görseli İndir",
         "type": "Tür"
     },
     "modelManager": {
@@ -382,9 +399,11 @@
         "defaultVAE": "Varsayılan VAE",
         "lora": "LoRA",
         "noModelsAvailable": "Model yok",
+        "noMatchingLoRAs": "Uygun LoRA Yok",
         "noMatchingModels": "Uygun Model Yok",
         "loading": "yükleniyor",
-        "selectModel": "Model Seçin"
+        "selectModel": "Model Seçin",
+        "noLoRAsInstalled": "LoRA Yok"
     },
     "settings": {
         "generation": "Oluşturma"
@@ -392,6 +411,7 @@
     "sdxl": {
         "cfgScale": "CFG Ölçeği",
         "loading": "Yükleniyor...",
-        "denoisingStrength": "Arındırma Ölçüsü"
+        "denoisingStrength": "Arındırma Ölçüsü",
+        "concatPromptStyle": "İstem ve Stili Bitiştir"
     }
 }

invokeai/frontend/web/public/locales/uk.json

@@ -22,7 +22,8 @@
     "gallery": {
         "galleryImageSize": "Розмір зображень",
         "gallerySettings": "Налаштування галереї",
-        "autoSwitchNewImages": "Автоматично вибирати нові"
+        "autoSwitchNewImages": "Автоматично вибирати нові",
+        "noImagesInGallery": "Зображень немає"
     },
     "modelManager": {
         "modelManager": "Менеджер моделей",
@@ -79,10 +80,12 @@
         "scaledHeight": "Масштаб В",
         "infillMethod": "Засіб заповнення",
         "tileSize": "Розмір області",
+        "downloadImage": "Завантажити",
         "usePrompt": "Використати запит",
         "useSeed": "Використати сід",
         "useAll": "Використати все",
         "info": "Метадані",
+        "showOptionsPanel": "Показати панель налаштувань",
         "general": "Основне",
         "denoisingStrength": "Сила шумоподавлення",
         "copyImage": "Копіювати зображення",

invokeai/frontend/web/public/locales/vi.json

@@ -20,6 +20,8 @@
         "addBoard": "Thêm Bảng",
         "downloadBoard": "Tải Xuống Bảng",
         "movingImagesToBoard_other": "Di chuyển {{count}} ảnh vào Bảng:",
+        "viewBoards": "Xem Bảng",
+        "hideBoards": "Ẩn Bảng",
         "noBoards": "Không Có Bảng Thuộc Loại {{boardType}}",
         "noMatching": "Không Có Bảng Tương Ứng",
         "searchBoard": "Tìm Bảng...",
@@ -53,12 +55,8 @@
         "assetsWithCount_other": "{{count}} tài nguyên",
         "uncategorizedImages": "Ảnh Chưa Sắp Xếp",
         "deleteAllUncategorizedImages": "Xoá Tất Cả Ảnh Chưa Sắp Xếp",
-        "locateInGalery": "Vị Trí Ở Thư Viện Ảnh",
-        "deletedImagesCannotBeRestored": "Ảnh đã xóa không thể khôi phục lại.",
-        "hideBoards": "Ẩn Bảng",
-        "movingVideosToBoard_other": "Di chuyển {{count}} video vào bảng:",
-        "viewBoards": "Xem Bảng",
-        "videosWithCount_other": "{{count}} video"
+        "deletedImagesCannotBeRestored": "Ảnh đã xoá không thể phục hồi lại.",
+        "locateInGalery": "Vị Trí Ở Thư Viện Ảnh"
     },
     "gallery": {
         "swapImages": "Đổi Hình Ảnh",
@@ -86,27 +84,33 @@
         "galleryImageSize": "Kích Thước Ảnh",
         "downloadSelection": "Tải xuống Phần Được Lựa Chọn",
         "bulkDownloadRequested": "Chuẩn Bị Tải Xuống",
+        "unableToLoad": "Không Thể Tải Thư viện Ảnh",
         "newestFirst": "Mới Nhất Trước",
         "showStarredImagesFirst": "Hiển Thị Ảnh Gắn Sao Trước",
         "bulkDownloadRequestedDesc": "Yêu cầu tải xuống đang được chuẩn bị. Vui lòng chờ trong giây lát.",
-        "starImage": "Gắn Sao",
+        "starImage": "Gắn Sao Cho Ảnh",
+        "openViewer": "Mở Trình Xem",
         "viewerImage": "Trình Xem Ảnh",
         "sideBySide": "Cạnh Nhau",
         "alwaysShowImageSizeBadge": "Luôn Hiển Thị Kích Thước Ảnh",
         "autoAssignBoardOnClick": "Tự Động Gán Vào Bảng Khi Nhấp Chuột",
+        "jump": "Nhảy Đến",
         "go": "Đi",
         "autoSwitchNewImages": "Tự Động Đổi Sang Hình Ảnh Mới",
         "featuresWillReset": "Nếu bạn xoá hình ảnh này, những tính năng đó sẽ lập tức được khởi động lại.",
         "openInViewer": "Mở Trong Trình Xem",
         "searchImages": "Tìm Theo Metadata",
         "selectForCompare": "Chọn Để So Sánh",
+        "closeViewer": "Đóng Trình Xem",
         "move": "Di Chuyển",
         "displayBoardSearch": "Tìm Kiếm Bảng",
         "displaySearch": "Tìm Kiếm Hình Ảnh",
+        "selectAnImageToCompare": "Chọn Ảnh Để So Sánh",
         "slider": "Thanh Trượt",
         "gallerySettings": "Cài Đặt Thư Viện Ảnh",
         "image": "hình ảnh",
         "noImageSelected": "Không Có Ảnh Được Chọn",
+        "noImagesInGallery": "Không Có Ảnh Để Hiển Thị",
         "assetsTab": "Tài liệu bạn đã tải lên để dùng cho dự án của mình.",
         "imagesTab": "Ảnh bạn vừa được tạo và lưu trong Invoke.",
         "loading": "Đang Tải",
@@ -114,24 +118,13 @@
         "exitCompare": "Ngừng So Sánh",
         "stretchToFit": "Kéo Dài Cho Vừa Vặn",
         "sortDirection": "Cách Sắp Xếp",
-        "unstarImage": "Bỏ Gắn Sao",
+        "unstarImage": "Ngừng Gắn Sao Cho Ảnh",
         "compareHelp2": "Nhấn <Kbd>M</Kbd> để tuần hoàn trong chế độ so sánh.",
         "boardsSettings": "Thiết Lập Bảng",
         "imagesSettings": "Cài Đặt Ảnh Trong Thư Viện Ảnh",
         "assets": "Tài Nguyên",
         "images": "Hình Ảnh",
-        "useForPromptGeneration": "Dùng Để Tạo Sinh Lệnh",
-        "deleteVideo_other": "Xóa {{count}} Video",
-        "deleteVideoPermanent": "Video đã xóa không thể khôi phục lại.",
-        "jump": "Nhảy Đến",
-        "noVideoSelected": "Không Có Video Được Chọn",
-        "noImagesInGallery": "Không Có Ảnh Để Hiển Thị",
-        "unableToLoad": "Không Thể Tải Thư Viện Ảnh",
-        "selectAnImageToCompare": "Chọn Ảnh Để So Sánh",
-        "openViewer": "Mở Trình Xem",
-        "closeViewer": "Đóng Trình Xem",
-        "videos": "Video",
-        "videosTab": "Video bạn tạo và được lưu trong Invoke."
+        "useForPromptGeneration": "Dùng Để Tạo Sinh Lệnh"
     },
     "common": {
         "ipAdapter": "IP Adapter",
@@ -142,12 +135,14 @@
         "clipboard": "Clipboard",
         "learnMore": "Tìm Hiểu Thêm",
         "openInViewer": "Mở Trong Trình Xem",
+        "nextPage": "Trang Sau",
         "alpha": "Alpha",
         "edit": "Sửa",
         "nodes": "Workflow",
         "format": "Định Dạng",
         "delete": "Xoá",
         "details": "Chi Tiết",
+        "imageFailedToLoad": "Không Thể Tải Hình Ảnh",
         "img2img": "Hình ảnh sang Hình ảnh",
         "upload": "Tải Lên",
         "somethingWentWrong": "Có vấn đề phát sinh",
@@ -163,7 +158,7 @@
         "dontAskMeAgain": "Không hỏi lại",
         "error": "Lỗi",
         "or": "hoặc",
-        "installed": "Được Tải Xuống Sẵn",
+        "installed": "Đã Tải Xuống",
         "simple": "Cơ Bản",
         "linear": "Tuyến Tính",
         "safetensors": "Safetensors",
@@ -185,15 +180,19 @@
         "on": "Bật",
         "checkpoint": "Checkpoint",
         "txt2img": "Từ Ngữ Sang Hình Ảnh",
+        "prevPage": "Trang Trước",
         "unknown": "Không Rõ",
         "githubLabel": "Github",
         "folder": "Thư mục",
+        "goTo": "Đến",
         "hotkeysLabel": "Phím Tắt",
         "loadingImage": "Đang Tải Hình ảnh",
+        "localSystem": "Hệ Thống Máy Chủ",
         "input": "Đầu Vào",
         "languagePickerLabel": "Ngôn Ngữ",
         "openInNewTab": "Mở Trong Tab Mới",
         "outpaint": "outpaint",
+        "notInstalled": "Chưa $t(common.installed)",
         "save": "Lưu",
         "saveAs": "Lưu Như",
         "auto": "Tự Động",
@@ -235,6 +234,7 @@
         "end": "Kết Thúc",
         "min": "Tối Thiểu",
         "max": "Tối Đa",
+        "resetToDefaults": "Đặt Lại Về Mặc Định",
         "seed": "Hạt Giống",
         "combinatorial": "Tổ Hợp",
         "column": "Cột",
@@ -256,14 +256,7 @@
         "options_withCount_other": "{{count}} thiết lập",
         "removeNegativePrompt": "Xóa Lệnh Tiêu Cực",
         "addNegativePrompt": "Thêm Lệnh Tiêu Cực",
-        "selectYourModel": "Chọn Model",
-        "goTo": "Đi Đến",
-        "imageFailedToLoad": "Không Thể Tải Ảnh",
-        "localSystem": "Hệ Thống Máy Chủ",
-        "notInstalled": "Chưa $t(common.installed)",
-        "prevPage": "Trang Trước",
-        "nextPage": "Trang Sau",
-        "resetToDefaults": "Tải Lại Mặc Định"
+        "selectYourModel": "Chọn Model"
     },
     "prompt": {
         "addPromptTrigger": "Thêm Trigger Cho Lệnh",
@@ -273,11 +266,11 @@
         "expandCurrentPrompt": "Mở Rộng Lệnh Hiện Tại",
         "uploadImageForPromptGeneration": "Tải Ảnh Để Tạo Sinh Lệnh",
         "expandingPrompt": "Đang mở rộng lệnh...",
-        "replace": "Thay Thế",
-        "discard": "Huỷ Bỏ",
         "resultTitle": "Mở Rộng Lệnh Hoàn Tất",
         "resultSubtitle": "Chọn phương thức mở rộng lệnh:",
-        "insert": "Chèn"
+        "replace": "Thay Thế",
+        "insert": "Chèn",
+        "discard": "Huỷ Bỏ"
     },
     "queue": {
         "resume": "Tiếp Tục",
@@ -291,6 +284,7 @@
         "clearQueueAlertDialog2": "Bạn chắc chắn muốn dọn sạch hàng không?",
         "queueEmpty": "Hàng Trống",
         "queueBack": "Thêm Vào Hàng",
+        "batchFieldValues": "Giá Trị Vùng Theo Lô",
         "openQueue": "Mở Queue",
         "pause": "Dừng Lại",
         "pauseFailed": "Có Vấn Đề Khi Dừng Lại Bộ Xử Lý",
@@ -354,13 +348,7 @@
         "retryFailed": "Có Vấn Đề Khi Thử Lại Mục",
         "retryItem": "Thử Lại Mục",
         "credits": "Nguồn",
-        "cancelAllExceptCurrent": "Huỷ Bỏ Tất Cả Ngoại Trừ Mục Hiện Tại",
-        "createdAt": "Tạo tại",
-        "completedAt": "Hoàn Thành Tại",
-        "sortColumn": "Sắp Xếp Cột",
-        "sortBy": "Sắp Xếp Theo {{column}}",
-        "sortOrderAscending": "Tăng Dần",
-        "sortOrderDescending": "Giảm Dần"
+        "cancelAllExceptCurrent": "Huỷ Bỏ Tất Cả Ngoại Trừ Mục Hiện Tại"
     },
     "hotkeys": {
         "canvas": {
@@ -512,14 +500,6 @@
             "toggleBbox": {
                 "title": "Bật/Tắt Hiển Thị Hộp Giới Hạn",
                 "desc": "Ẩn hoặc hiện hộp giới hạn tạo sinh"
-            },
-            "setFillColorsToDefault": {
-                "title": "Đặt Màu Lại Mặc Định",
-                "desc": "Chỉnh công cụ màu hiện tại về mặc định."
-            },
-            "toggleFillColor": {
-                "title": "Bật/Tắt Màu Lấp Đầy",
-                "desc": "Bật/Tắt công cụ đổ màu hiện tại."
             }
         },
         "workflows": {
@@ -717,19 +697,12 @@
                 "title": "Chọn Tab Tạo Sinh",
                 "desc": "Chọn tab Tạo Sinh.",
                 "key": "1"
-            },
-            "selectVideoTab": {
-                "title": "Chọn Thẻ Video",
-                "desc": "Chọn thẻ Video."
             }
         },
         "searchHotkeys": "Tìm Phím tắt",
         "noHotkeysFound": "Không Tìm Thấy Phím Tắt",
         "clearSearch": "Làm Sạch Thanh Tìm Kiếm",
-        "hotkeys": "Phím Tắt",
-        "video": {
-            "title": "Video"
-        }
+        "hotkeys": "Phím Tắt"
     },
     "modelManager": {
         "modelConverted": "Model Đã Được Chuyển Đổi",
@@ -813,6 +786,7 @@
         "hfTokenUnableToVerifyErrorMessage": "Không thể xác minh HuggingFace token. Khả năng cao lỗi mạng. Vui lòng thử lại sau.",
         "inplaceInstall": "Tải Xuống Tại Chỗ",
         "installRepo": "Tải Xuống Kho Lưu Trữ (Repository)",
+        "ipAdapters": "IP Adapters",
         "loraModels": "LoRA",
         "main": "Chính",
         "modelConversionFailed": "Chuyển Đổi Model Thất Bại",
@@ -858,6 +832,7 @@
         "textualInversions": "Bộ Đảo Ngược Văn Bản",
         "loraTriggerPhrases": "Từ Ngữ Kích Hoạt Cho LoRA",
         "width": "Chiều Rộng",
+        "starterModelsInModelManager": "Model khởi đầu có thể tìm thấy ở Trình Quản Lý Model",
         "clipLEmbed": "CLIP-L Embed",
         "clipGEmbed": "CLIP-G Embed",
         "controlLora": "LoRA Điều Khiển Được",
@@ -869,11 +844,13 @@
         "sigLip": "SigLIP",
         "llavaOnevision": "LLaVA OneVision",
         "fileSize": "Kích Thước Tệp",
+        "filterModels": "Lọc Model",
         "modelPickerFallbackNoModelsInstalled2": "Nhấp vào <LinkComponent>Trình Quản Lý Model</LinkComponent> để tải.",
         "modelPickerFallbackNoModelsInstalled": "Không Có Sẵn Model.",
         "manageModels": "Quản Lý Model",
         "hfTokenReset": "Làm Mới HF Token",
         "relatedModels": "Model Liên Quan",
+        "showOnlyRelatedModels": "Liên Quan",
         "installedModelsCount": "Đã tải {{installed}} trên {{total}} model.",
         "allNModelsInstalled": "Đã tải tất cả {{count}} model",
         "nToInstall": "Còn {{count}} để tải",
@@ -890,32 +867,30 @@
             "scanFolderDescription": "Quét một thư mục trên máy để tự động tra và tải model.",
             "recommendedModels": "Model Khuyến Nghị",
             "exploreStarter": "Hoặc duyệt tất cả model khởi đầu có sẵn",
-            "bundleDescription": "Các gói đều bao gồm những model cần thiết cho từng nhánh model và những model cơ sở đã chọn lọc để bắt đầu.",
-            "sdxl": "SDXL",
             "quickStart": "Gói Khởi Đầu Nhanh",
+            "bundleDescription": "Các gói đều bao gồm những model cần thiết cho từng nhánh model và những model cơ sở đã chọn lọc để bắt đầu.",
             "browseAll": "Hoặc duyệt tất cả model có sẵn:",
             "stableDiffusion15": "Stable Diffusion 1.5",
+            "sdxl": "SDXL",
             "fluxDev": "FLUX.1 dev"
         },
         "installBundle": "Tải Xuống Gói",
         "installBundleMsg1": "Bạn có chắc chắn muốn tải xuống gói {{bundleName}}?",
-        "installBundleMsg2": "Gói này sẽ tải xuống {{count}} model sau đây:",
-        "filterModels": "Lọc Model",
-        "ipAdapters": "IP Adapters",
-        "showOnlyRelatedModels": "Liên Quan",
-        "starterModelsInModelManager": "Model Khởi Đầu có thể tìm thấy ở Trình Quản Lý Model"
+        "installBundleMsg2": "Gói này sẽ tải xuống {{count}} model sau đây:"
     },
     "metadata": {
         "guidance": "Hướng Dẫn",
         "noRecallParameters": "Không tìm thấy tham số",
         "imageDetails": "Chi Tiết Ảnh",
         "createdBy": "Được Tạo Bởi",
+        "parsingFailed": "Lỗi Cú Pháp",
         "canvasV2Metadata": "Layer Canvas",
         "parameterSet": "Dữ liệu tham số {{parameter}}",
         "positivePrompt": "Lệnh Tích Cực",
+        "recallParameter": "Gợi Nhớ {{label}}",
         "seed": "Hạt Giống",
         "negativePrompt": "Lệnh Tiêu Cực",
-        "noImageDetails": "Không tìm thấy chi tiết ảnh",
+        "noImageDetails": "Không tìm thấy chí tiết ảnh",
         "strength": "Mức độ mạnh từ ảnh sang ảnh",
         "Threshold": "Ngưỡng Nhiễu",
         "width": "Chiều Rộng",
@@ -935,15 +910,7 @@
         "scheduler": "Scheduler",
         "noMetaData": "Không tìm thấy metadata",
         "imageDimensions": "Kích Thước Ảnh",
-        "clipSkip": "$t(parameters.clipSkip)",
-        "videoDetails": "Chi Tiết Video",
-        "noVideoDetails": "Không tìm thấy chi tiết video",
-        "parsingFailed": "Lỗi Cú Pháp",
-        "recallParameter": "Gợi Nhớ {{label}}",
-        "videoModel": "Model",
-        "videoDuration": "Thời Lượng",
-        "videoAspectRatio": "Tỉ Lệ",
-        "videoResolution": "Độ Phân Giải"
+        "clipSkip": "$t(parameters.clipSkip)"
     },
     "accordions": {
         "generation": {
@@ -989,8 +956,8 @@
             "method": "Cách Thức Sửa Độ Phân Giải Cao"
         },
         "hrf": "Sửa Độ Phân Giải Cao",
-        "enableHrf": "Bật Chế Độ Chỉnh Sửa Phân Giải Cao",
-        "upscaleMethod": "Phương Thức Upscale"
+        "enableHrf": "Cho Phép Sửa Độ Phân Giải Cao",
+        "upscaleMethod": "Cách Thức Upscale"
     },
     "nodes": {
         "validateConnectionsHelp": "Ngăn chặn những kết nối không hợp lý được tạo ra, và đồ thị không hợp lệ bị kích hoạt",
@@ -1016,7 +983,9 @@
         "float": "Số Thực",
         "missingNode": "Thiếu node kích hoạt",
         "currentImage": "Hình Ảnh Hiện Tại",
+        "removeLinearView": "Xoá Khỏi Chế Độ Xem Tuyến Tính",
         "unknownErrorValidatingWorkflow": "Lỗi không rõ khi xác thực workflow",
+        "unableToLoadWorkflow": "Không Thể Tải Workflow",
         "workflowSettings": "Cài Đặt Biên Tập Workflow",
         "workflowVersion": "Phiên Bản",
         "unableToGetWorkflowVersion": "Không thể tìm phiên bản của lược đồ workflow",
@@ -1026,6 +995,7 @@
         "ipAdapter": "IP Adapter",
         "cannotDuplicateConnection": "Không thể tạo hai kết nối trùng lặp",
         "workflowValidation": "Lỗi Xác Thực Workflow",
+        "mismatchedVersion": "Node không hợp lệ: node {{node}} thuộc loại {{type}} có phiên bản không khớp (thử cập nhật?)",
         "sourceNodeFieldDoesNotExist": "Kết nối không phù hợp: nguồn/đầu ra của vùng {{node}}.{{field}} không tồn tại",
         "targetNodeFieldDoesNotExist": "Kết nối không phù hợp: đích đến/đầu vào của vùng {{node}}.{{field}} không tồn tại",
         "missingTemplate": "Node không hợp lệ: node {{node}} thuộc loại {{type}} bị thiếu mẫu trình bày (chưa tải?)",
@@ -1039,6 +1009,7 @@
         "edge": "Kết Nối",
         "graph": "Đồ Thị",
         "workflowAuthor": "Tác Giả",
+        "addLinearView": "Thêm Vào Chế Độ Xem Tuyến Tính",
         "showEdgeLabels": "Hiển Thị Tên Kết Nối",
         "unknownField": "Vùng Dữ Liệu Không Rõ",
         "executionStateCompleted": "Đã Hoàn Tất",
@@ -1068,6 +1039,7 @@
         "node": "Node",
         "nodeTemplate": "Mẫu Trình Bày Của Node",
         "nodeType": "Loại Node",
+        "noFieldsLinearview": "Không có vùng được thêm vào Chế Độ Xem Tuyến Tính",
         "notes": "Ghi Chú",
         "updateApp": "Cập Nhật Ứng Dụng",
         "updateAllNodes": "Cập Nhật Các Node",
@@ -1075,6 +1047,7 @@
         "imageAccessError": "Không thể tìm thấy ảnh {{image_name}}, chuyển về mặc định",
         "unknownNode": "Node Không Rõ",
         "unknownNodeType": "Loại Node Không Rõ",
+        "unknownTemplate": "Mẫu Trình Bày Không Rõ",
         "cannotConnectOutputToOutput": "Không thế kết nối đầu ra với đầu ra",
         "cannotConnectToSelf": "Không thể kết nối với chính nó",
         "workflow": "Workflow",
@@ -1090,6 +1063,7 @@
         "fitViewportNodes": "Chế Độ Xem Vừa Khớp",
         "fullyContainNodes": "Bao Phủ Node Hoàn Toàn Để Chọn",
         "fullyContainNodesHelp": "Node phải được phủ kín hoàn toàn trong hộp lựa chọn để được lựa chọn",
+        "hideLegendNodes": "Ẩn Vùng Nhập",
         "hideMinimapnodes": "Ẩn Bản Đồ Thu Nhỏ",
         "inputMayOnlyHaveOneConnection": "Đầu vào chỉ có thể có một kết nối",
         "noWorkflows": "Không Có Workflow",
@@ -1100,27 +1074,34 @@
         "problemSettingTitle": "Có Vấn Đề Khi Thiết Lập Tiêu Đề",
         "resetToDefaultValue": "Đặt lại giá trị mặc định",
         "reloadNodeTemplates": "Tải Lại Mẫu Trình Bày Node",
+        "reorderLinearView": "Sắp Xếp Lại Chế Độ Xem Tuyến Tính",
         "viewMode": "Dùng Chế Độ Xem Tuyến Tính",
         "newWorkflowDesc": "Tạo workflow mới?",
         "string": "Chuỗi Ký Tự",
         "version": "Phiên Bản",
+        "versionUnknown": " Phiên Bản Không Rõ",
         "workflowContact": "Thông Tin Liên Lạc",
         "workflowName": "Tên",
         "saveToGallery": "Lưu Vào Thư Viện Ảnh",
         "connectionWouldCreateCycle": "Kết nối này sẽ tạo ra vòng lặp",
         "addNode": "Thêm Node",
         "unsupportedAnyOfLength": "quá nhiều dữ liệu hợp nhất: {{count}}",
+        "unknownInput": "Đầu Vào Không Rõ: {{name}}",
         "validateConnections": "Xác Thực Kết Nối Và Đồ Thị",
         "workflowNotes": "Ghi Chú",
         "workflowTags": "Nhãn",
         "editMode": "Chỉnh sửa trong Trình Biên Tập Workflow",
         "edit": "Chỉnh Sửa",
         "executionStateInProgress": "Đang Xử Lý",
+        "showLegendNodes": "Hiển Thị Vùng Nhập",
         "outputFieldTypeParseError": "Không thể phân tích loại dữ liệu đầu ra của {{node}}.{{field}} ({{message}})",
         "modelAccessError": "Không thể tìm thấy model {{key}}, chuyển về mặc định",
         "internalDesc": "Trình kích hoạt này được dùng bên trong bởi Invoke. Nó có thể phá hỏng thay đổi trong khi cập nhật ứng dụng và có thể bị xoá bất cứ lúc nào.",
         "specialDesc": "Trình kích hoạt này có một số xử lý đặc biệt trong ứng dụng. Ví dụ, Node Hàng Loạt được dùng để xếp vào nhiều đồ thị từ một workflow.",
         "addItem": "Thêm Mục",
+        "generateValues": "Cho Ra Giá Trị",
+        "floatRangeGenerator": "Phạm Vị Tạo Ra Số Thực",
+        "integerRangeGenerator": "Phạm Vị Tạo Ra Số Nguyên",
         "linearDistribution": "Phân Bố Tuyến Tính",
         "uniformRandomDistribution": "Phân Bố Ngẫu Nhiên Đồng Nhất",
         "parseString": "Phân Tích Chuỗi",
@@ -1129,6 +1110,7 @@
         "splitOn": "Tách Ở",
         "arithmeticSequence": "Cấp Số Cộng",
         "generatorNRandomValues_other": "{{count}} giá trị ngẫu nhiên",
+        "generatorLoading": "đang tải",
         "generatorLoadFromFile": "Tải Từ Tệp",
         "dynamicPromptsRandom": "Dynamic Prompts (Ngẫu Nhiên)",
         "dynamicPromptsCombinatorial": "Dynamic Prompts (Tổ Hợp)",
@@ -1138,6 +1120,7 @@
         "description": "Mô Tả",
         "loadWorkflowDesc": "Tải workflow?",
         "loadWorkflowDesc2": "Workflow hiện tại của bạn có những điều chỉnh chưa được lưu.",
+        "loadingTemplates": "Đang Tải {{name}}",
         "nodeName": "Tên Node",
         "unableToUpdateNode": "Cập nhật node thất bại: node {{node}} thuộc dạng {{type}} (có thể cần xóa và tạo lại)",
         "downloadWorkflowError": "Lỗi tải xuống workflow",
@@ -1163,23 +1146,7 @@
             "alignmentDL": "Dưới Cùng Bên Trái",
             "alignmentUR": "Trên Cùng Bên Phải",
             "alignmentDR": "Dưới Cùng Bên Phải"
-        },
-        "generatorLoading": "đang tải",
-        "addLinearView": "Thêm Vào Chế Độ Xem Tuyến Tính (Linear View)",
-        "hideLegendNodes": "Ẩn Vùng Nhập",
-        "mismatchedVersion": "Node không hợp lệ: node {{node}} thuộc loại {{type}} có phiên bản không khớp (thử cập nhật?)",
-        "noFieldsLinearview": "Không có vùng được thêm vào Chế Độ Xem Tuyến Tính",
-        "removeLinearView": "Xoá Khỏi Chế Độ Xem Tuyến Tính",
-        "reorderLinearView": "Sắp Xếp Lại Chế Độ Xem Tuyến Tính",
-        "showLegendNodes": "Hiển Thị Vùng Nhập",
-        "unableToLoadWorkflow": "Không Thể Tải Workflow",
-        "unknownTemplate": "Mẫu Trình Bày Không Rõ",
-        "unknownInput": "Đầu Vào Không Rõ: {{name}}",
-        "loadingTemplates": "Đang Tải {{name}}",
-        "versionUnknown": " Phiên Bản Không Rõ",
-        "generateValues": "Giá Trị Tạo Sinh",
-        "floatRangeGenerator": "Phạm Vị Tạo Sinh Số Thực",
-        "integerRangeGenerator": "Phạm Vị Tạo Sinh Số Nguyên"
+        }
     },
     "popovers": {
         "paramCFGRescaleMultiplier": {
@@ -1627,14 +1594,14 @@
         "concepts": "LoRA",
         "loading": "đang tải",
         "lora": "LoRA",
+        "noMatchingLoRAs": "Không có LoRA phù hợp",
         "noRefinerModelsInstalled": "Chưa có model SDXL Refiner được tải xuống",
+        "noLoRAsInstalled": "Chưa có LoRA được tải xuống",
         "defaultVAE": "VAE Mặc Định",
         "noMatchingModels": "Không có Model phù hợp",
         "noModelsAvailable": "Không có model",
         "selectModel": "Chọn Model",
-        "noCompatibleLoRAs": "Không Có LoRAs Tương Thích",
-        "noMatchingLoRAs": "Không có LoRA phù hợp",
-        "noLoRAsInstalled": "Chưa có LoRA được tải xuống"
+        "noCompatibleLoRAs": "Không Có LoRAs Tương Thích"
     },
     "parameters": {
         "postProcessing": "Xử Lý Hậu Kỳ (Shift + U)",
@@ -1644,7 +1611,9 @@
         "processImage": "Xử Lý Hình Ảnh",
         "useSize": "Dùng Kích Thước",
         "invoke": {
+            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), chiều rộng hộp giới hạn là {{width}}",
             "noModelSelected": "Không có model được lựa chọn",
+            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), tỉ lệ chiều dài hộp giới hạn là {{height}}",
             "canvasIsFiltering": "Canvas đang bận (đang lọc)",
             "canvasIsRasterizing": "Canvas đang bận (đang raster hoá)",
             "canvasIsTransforming": "Canvas đang bận (đang biến đổi)",
@@ -1658,6 +1627,8 @@
             "systemDisconnected": "Hệ thống mất kết nối",
             "invoke": "Kích Hoạt",
             "missingNodeTemplate": "Thiếu mẫu trình bày node",
+            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), chiều dài hộp giới hạn là {{height}}",
+            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), tỉ lệ chiều rộng hộp giới hạn là {{width}}",
             "missingInputForField": "thiếu đầu vào",
             "missingFieldTemplate": "Thiếu vùng mẫu trình bày",
             "collectionTooFewItems": "quá ít mục, tối thiểu là {{minItems}}",
@@ -1672,6 +1643,7 @@
             "collectionNumberLTExclusiveMin": "{{value}} <= {{exclusiveMinimum}} (giá trị chọn lọc tối thiểu)",
             "collectionNumberGTExclusiveMax": "{{value}} >= {{exclusiveMaximum}} (giá trị chọn lọc tối đa)",
             "batchNodeCollectionSizeMismatch": "Kích cỡ tài nguyên không phù hợp với Lô {{batchGroupId}}",
+            "emptyBatches": "lô trống",
             "batchNodeNotConnected": "Node Hàng Loạt chưa được kết nối: {{label}}",
             "batchNodeEmptyCollection": "Một vài node hàng loạt có tài nguyên rỗng",
             "collectionEmpty": "tài nguyên trống",
@@ -1682,15 +1654,7 @@
             "modelIncompatibleScaledBboxWidth": "Chiều rộng hộp giới hạn theo tỉ lệ là {{width}} nhưng {{model}} yêu cầu bội số của {{multiple}}",
             "modelDisabledForTrial": "Tạo sinh với {{modelName}} là không thể với tài khoản trial. Vào phần thiết lập tài khoản để nâng cấp.",
             "promptExpansionPending": "Trong quá trình mở rộng lệnh",
-            "promptExpansionResultPending": "Hãy chấp thuận hoặc huỷ bỏ kết quả mở rộng lệnh của bạn",
-            "emptyBatches": "lô trống",
-            "noStartingFrameImage": "Chưa có khung hình ảnh đầu",
-            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), chiều rộng hộp giới hạn là {{width}}",
-            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), chiều cao hộp giới hạn là {{height}}",
-            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), tỉ lệ chiều rộng hộp giới hạn là {{width}}",
-            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16), tỉ lệ chiều cao hộp giới hạn là {{height}}",
-            "incompatibleLoRAs": "LoRA không tương thích bị thêm vào",
-            "videoIsDisabled": "Trình tạo sinh Video không được mở cho tài khoản {{accountType}}."
+            "promptExpansionResultPending": "Hãy chấp thuận hoặc huỷ bỏ kết quả mở rộng lệnh của bạn"
         },
         "cfgScale": "Thang CFG",
         "useSeed": "Dùng Hạt Giống",
@@ -1737,6 +1701,7 @@
         "useAll": "Dùng Tất Cả",
         "useCpuNoise": "Dùng Độ Nhiễu CPU",
         "remixImage": "Phối Lại Hình Ảnh",
+        "showOptionsPanel": "Hiển Thị Bảng Bên Cạnh (O hoặc T)",
         "shuffle": "Xáo Trộn",
         "setToOptimalSizeTooLarge": "$t(parameters.setToOptimalSize) (lớn quá)",
         "cfgRescaleMultiplier": "Hệ Số Nhân Thang CFG",
@@ -1746,6 +1711,7 @@
         "lockAspectRatio": "Khoá Tỉ Lệ",
         "swapDimensions": "Hoán Đổi Kích Thước",
         "copyImage": "Sao Chép Hình Ảnh",
+        "downloadImage": "Tải Xuống Hình Ảnh",
         "imageFit": "Căn Chỉnh Ảnh Ban Đầu Thành Kích Thước Đầu Ra",
         "info": "Thông Tin",
         "usePrompt": "Dùng Lệnh",
@@ -1753,17 +1719,7 @@
         "tileSize": "Kích Thước Khối",
         "disabledNoRasterContent": "Đã Tắt (Không Có Nội Dung Dạng Raster)",
         "modelDisabledForTrial": "Tạo sinh với {{modelName}} là không thể với tài khoản trial. Vào phần <LinkComponent>thiết lập tài khoản</LinkComponent> để nâng cấp.",
-        "useClipSkip": "Dùng CLIP Skip",
-        "duration": "Thời Lượng",
-        "downloadImage": "Tải Xuống Hình Ảnh",
-        "images_withCount_other": "Hình Ảnh",
-        "videos_withCount_other": "Video",
-        "startingFrameImage": "Khung Hình Bắt Đầu",
-        "videoActions": "Hành Động Với Video",
-        "sendToVideo": "Gửi Vào Video",
-        "showOptionsPanel": "Hiển Thị Bảng Bên Cạnh (O hoặc T)",
-        "video": "Video",
-        "resolution": "Độ Phân Giải"
+        "useClipSkip": "Dùng CLIP Skip"
     },
     "dynamicPrompts": {
         "seedBehaviour": {
@@ -1789,7 +1745,9 @@
         "antialiasProgressImages": "Xử Lý Khử Răng Cưa Hình Ảnh",
         "models": "Models",
         "informationalPopoversDisabledDesc": "Hộp thoại hỗ trợ thông tin đã tắt. Bật lại trong Cài đặt.",
+        "modelDescriptionsDisabled": "Trình Mô Tả Model Bằng Hộp Thả Đã Tắt",
         "enableModelDescriptions": "Bật Trình Mô Tả Model Bằng Hộp Thả",
+        "modelDescriptionsDisabledDesc": "Trình mô tả model bằng hộp thả đã tắt. Bật lại trong Cài đặt.",
         "enableNSFWChecker": "Bật Trình Kiểm Tra NSFW",
         "clearIntermediatesWithCount_other": "Dọn sạch {{count}} sản phẩm trung gian",
         "reloadingIn": "Tải lại trong",
@@ -1812,9 +1770,7 @@
         "intermediatesClearedFailed": "Có Vấn Đề Khi Dọn Sạch Sản Phẩm Trung Gian",
         "enableInvisibleWatermark": "Bật Chế Độ Ẩn Watermark",
         "showDetailedInvocationProgress": "Hiện Dữ Liệu Xử Lý",
-        "enableHighlightFocusedRegions": "Nhấn Mạnh Khu Vực Chỉ Định",
-        "modelDescriptionsDisabled": "Trình Mô Tả Model Bằng Hộp Thả Đã Tắt",
-        "modelDescriptionsDisabledDesc": "Trình mô tả model bằng hộp thả đã tắt. Bật lại trong Cài đặt."
+        "enableHighlightFocusedRegions": "Nhấn Mạnh Khu Vực Chỉ Định"
     },
     "sdxl": {
         "loading": "Đang Tải...",
@@ -1824,15 +1780,15 @@
         "refinermodel": "Model Refiner",
         "refinerStart": "Bắt Đầu Refiner",
         "denoisingStrength": "Sức Mạnh Khử Nhiễu",
+        "posStylePrompt": "Điểm Tích Cực Cho Lệnh Phong Cách",
         "scheduler": "Scheduler",
         "refiner": "Refiner",
         "cfgScale": "Thang CFG",
-        "negAestheticScore": "Điểm Khác Tiêu Chuẩn",
-        "noModelsAvailable": "Không có sẵn model",
         "concatPromptStyle": "Liên Kết Lệnh & Phong Cách",
-        "freePromptStyle": "Viết Thủ Công Lệnh Phong Cách",
+        "freePromptStyle": "Viết Lệnh Thủ Công Cho Phong Cách",
         "negStylePrompt": "Điểm Tiêu Cực Cho Lệnh Phong Cách",
-        "posStylePrompt": "Điểm Tích Cực Cho Lệnh Phong Cách"
+        "negAestheticScore": "Điểm Khác Tiêu Chuẩn",
+        "noModelsAvailable": "Không có sẵn model"
     },
     "controlLayers": {
         "width": "Chiều Rộng",
@@ -1847,6 +1803,7 @@
         "saveLayerToAssets": "Lưu Layer Vào Khu Tài Nguyên",
         "canvas": "Canvas",
         "savedToGalleryOk": "Đã Lưu Vào Thư Viện Ảnh",
+        "addGlobalReferenceImage": "Thêm $t(controlLayers.globalReferenceImage)",
         "clipToBbox": "Chuyển Nét Thành Hộp Giới Hạn",
         "moveToFront": "Chuyển Lên Trước",
         "mergeVisible": "Gộp Layer Đang Hiển Thị",
@@ -1891,6 +1848,7 @@
             "stylePrecise": "Phong Cách (Chính Xác)",
             "stylePreciseDesc": "Áp dụng cách trình bày chính xác, loại bỏ các chủ thể ảnh hưởng."
         },
+        "deletePrompt": "Xoá Lệnh",
         "rasterLayer": "Layer Dạng Raster",
         "disableAutoNegative": "Tắt Tự Động Đảo Chiều",
         "controlLayer": "Layer Điều Khiển Được",
@@ -1901,6 +1859,8 @@
         "replaceLayer": "Thay Đổi Layer",
         "regionalGuidance": "Chỉ Dẫn Khu Vực",
         "newCanvasFromImage": "Canvas Mới Từ Ảnh",
+        "rasterLayers_withCount_visible": "Layer Dạng Raster ({{count}})",
+        "regionalGuidance_withCount_visible": "Chỉ Dẫn Khu Vực ({{count}})",
         "convertRasterLayerTo": "Chuyển Đổi $t(controlLayers.rasterLayer) Thành",
         "convertControlLayerTo": "Chuyển Đổi $t(controlLayers.controlLayer) Thành",
         "convertInpaintMaskTo": "Chuyển Đổi $t(controlLayers.inpaintMask) Thành",
@@ -1911,7 +1871,12 @@
         "newRasterLayer": "$t(controlLayers.rasterLayer) Mới",
         "enableAutoNegative": "Bật Tự Động Đảo Chiều",
         "sendToCanvas": "Chuyển Tới Canvas",
+        "inpaintMasks_withCount_hidden": "Lớp Phủ Inpaint ({{count}} đang ẩn)",
+        "globalReferenceImages_withCount_visible": "Ảnh Mẫu Toàn Vùng ({{count}})",
+        "replaceCurrent": "Thay Đổi Cái Hiện Tại",
+        "controlLayers_withCount_visible": "Layer Điều Khiển Được ({{count}})",
         "hidingType": "Ẩn {{type}}",
+        "newImg2ImgCanvasFromImage": "Chuyển Đổi Ảnh Sang Ảnh Mới Từ Ảnh",
         "copyToClipboard": "Sao Chép Vào Clipboard",
         "logDebugInfo": "Thông Tin Log Gỡ Lỗi",
         "regionalReferenceImage": "Ảnh Mẫu Khu Vực",
@@ -1924,28 +1889,37 @@
             "horizontal": "Đường Ngang",
             "crosshatch": "Đường Chéo Song Song (Crosshatch)",
             "vertical": "Đường Dọc",
-            "solid": "Chắc Chắn",
-            "bgFillColor": "Màu Nền",
-            "fgFillColor": "Màu Nổi"
+            "solid": "Chắc Chắn"
         },
         "addControlLayer": "Thêm $t(controlLayers.controlLayer)",
         "inpaintMask": "Lớp Phủ Inpaint",
         "dynamicGrid": "Lưới Dynamic",
         "layer_other": "Layer",
+        "layer_withCount_other": "Layer ({{count}})",
         "pullBboxIntoLayer": "Chuyển Hộp Giới Hạn Vào Layer",
         "addInpaintMask": "Thêm $t(controlLayers.inpaintMask)",
         "addRegionalGuidance": "Thêm $t(controlLayers.regionalGuidance)",
+        "sendToGallery": "Đã Chuyển Tới Thư Viện Ảnh",
         "unlocked": "Mở Khoá",
         "addReferenceImage": "Thêm $t(controlLayers.referenceImage)",
+        "sendingToCanvas": "Chuyển Ảnh Tạo Sinh Vào Canvas",
+        "sendingToGallery": "Chuyển Ảnh Tạo Sinh Vào Thư Viện Ảnh",
+        "viewProgressOnCanvas": "Xem quá trình xử lý và ảnh đầu ra trong <Btn>Canvas</Btn>.",
         "inpaintMask_withCount_other": "Lớp Phủ Inpaint",
         "regionalGuidance_withCount_other": "Chỉ Dẫn Khu Vực",
+        "controlLayers_withCount_hidden": "Layer Điều Khiển Được ({{count}} đang ẩn)",
+        "globalReferenceImages_withCount_hidden": "Ảnh Mẫu Toàn Vùng ({{count}} đang ẩn)",
         "rasterLayer_withCount_other": "Layer Dạng Raster",
+        "globalReferenceImage_withCount_other": "Ảnh Mẫu Toàn Vùng",
         "copyRasterLayerTo": "Sao Chép $t(controlLayers.rasterLayer) Tới",
         "copyControlLayerTo": "Sao Chép $t(controlLayers.controlLayer) Tới",
         "newRegionalGuidance": "$t(controlLayers.regionalGuidance) Mới",
+        "newGallerySessionDesc": "Nó sẽ dọn sạch canvas và các thiết lập trừ model được chọn. Các ảnh được tạo sinh sẽ được chuyển đến thư viện ảnh.",
+        "stagingOnCanvas": "Hiển thị hình ảnh lên",
         "pullBboxIntoReferenceImage": "Chuyển Hộp Giới Hạn Vào Ảnh Mẫu",
         "maskFill": "Lấp Đầy Lớp Phủ",
         "addRasterLayer": "Thêm $t(controlLayers.rasterLayer)",
+        "rasterLayers_withCount_hidden": "Layer Dạng Raster ({{count}} đang ẩn)",
         "referenceImage": "Ảnh Mẫu",
         "showProgressOnCanvas": "Hiện Quá Trình Xử Lý Lên Canvas",
         "prompt": "Lệnh",
@@ -1960,23 +1934,34 @@
         },
         "addPositivePrompt": "Thêm $t(controlLayers.prompt)",
         "deleteReferenceImage": "Xoá Ảnh Mẫu",
+        "inpaintMasks_withCount_visible": "Lớp Phủ Inpaint ({{count}})",
         "disableTransparencyEffect": "Tắt Hiệu Ứng Trong Suốt",
+        "newGallerySession": "Phiên Thư Viện Ảnh Mới",
+        "sendToGalleryDesc": "Bấm 'Kích Hoạt' sẽ tiến hành tạo sinh và lưu ảnh vào thư viện ảnh.",
         "opacity": "Độ Mờ Đục",
         "rectangle": "Hình Chữ Nhật",
         "addNegativePrompt": "Thêm $t(controlLayers.negativePrompt)",
         "globalReferenceImage": "Ảnh Mẫu Toàn Vùng",
+        "sendToCanvasDesc": "Bấm 'Kích Hoạt' sẽ hiển thị công việc đang xử lý của bạn lên canvas.",
+        "viewProgressInViewer": "Xem quá trình xử lý và ảnh đầu ra trong <Btn>Trình Xem Ảnh</Btn>.",
+        "regionalGuidance_withCount_hidden": "Chỉ Dẫn Khu Vực ({{count}} đang ẩn)",
         "controlLayer_withCount_other": "Layer Điều Khiển Được",
         "newInpaintMask": "$t(controlLayers.inpaintMask) Mới",
         "locked": "Khoá",
+        "newCanvasSession": "Phiên Canvas Mới",
         "transparency": "Độ Trong Suốt",
         "showingType": "Hiển Thị {{type}}",
+        "newCanvasSessionDesc": "Nó sẽ dọn sạch canvas và các thiết lập trừ model được chọn. Các ảnh được tạo sinh sẽ được chuyển đến canvas.",
         "selectObject": {
+            "help2": "Bắt đầu mới một điểm <Bold>Bao Gồm</Bold> trong đối tượng được chọn. Cho thêm điểm để tinh chế phần chọn. Ít điểm hơn thường mang lại kết quả tốt hơn.",
             "invertSelection": "Đảo Ngược Phần Chọn",
             "include": "Bao Gồm",
             "exclude": "Loại Trừ",
             "reset": "Làm Mới",
             "saveAs": "Lưu Như",
+            "help1": "Chọn một đối tượng. Thêm điểm <Bold>Bao Gồm</Bold> và <Bold>Loại Trừ</Bold> để chỉ ra phần nào trong layer là đối tượng mong muốn.",
             "dragToMove": "Kéo kiểm để di chuyển nó",
+            "help3": "Đảo ngược phần chọn để chọn mọi thứ trừ đối tượng được chọn.",
             "clickToAdd": "Nhấp chuột vào layer để thêm điểm",
             "clickToRemove": "Nhấp chuột vào một điểm để xoá",
             "selectObject": "Chọn Đối Tượng",
@@ -2210,6 +2195,7 @@
         "newSession": "Phiên Làm Việc Mới",
         "resetGenerationSettings": "Khởi Động Lại Cài Đặt Tạo Sinh",
         "referenceImageRegional": "Ảnh Mẫu (Khu Vực)",
+        "referenceImageGlobal": "Ảnh Mẫu (Toàn Vùng)",
         "warnings": {
             "problemsFound": "Phát hiện vấn đề",
             "unsupportedModel": "layer không được hỗ trợ cho model cơ sở này",
@@ -2234,6 +2220,7 @@
         "pasteToBboxDesc": "Layer Mới (Trong Hộp Giới Hạn)",
         "pasteToCanvas": "Canvas",
         "pasteToCanvasDesc": "Layer Mới (Trong Canvas)",
+        "pastedTo": "Dán Vào {{destination}}",
         "regionCopiedToClipboard": "Sao Chép {{region}} Vào Clipboard",
         "copyRegionError": "Lỗi khi sao chép {{region}}",
         "errors": {
@@ -2253,6 +2240,7 @@
         "denoiseLimit": "Giới Hạn Khử Nhiễu",
         "addImageNoise": "Thêm $t(controlLayers.imageNoise)",
         "referenceImageEmptyStateWithCanvasOptions": "<UploadButton>Tải lên hình ảnh</UploadButton>, kéo ảnh từ thư viện ảnh vào Ảnh Mẫu này, hoặc <PullBboxButton>kéo hộp giới hạn vào Ảnh Mẫu này</PullBboxButton> để bắt đầu.",
+        "uploadOrDragAnImage": "Kéo ảnh từ thư viện ảnh hoặc <UploadButton>tải lên ảnh</UploadButton>.",
         "exportCanvasToPSD": "Xuất Canvas Thành File PSD",
         "ruleOfThirds": "Hiển Thị Quy Tắc Một Phần Ba",
         "showNonRasterLayers": "Hiển Thị Layer Không Thuộc Dạng Raster (Shift + H)",
@@ -2265,38 +2253,7 @@
         "fitBboxToMasks": "Xếp Vừa Hộp Giới Hạn Vào Lớp Phủ",
         "invertMask": "Đảo Ngược Lớp Phủ",
         "maxRefImages": "Ảnh Mẫu Tối Đa",
-        "useAsReferenceImage": "Dùng Làm Ảnh Mẫu",
-        "deletePrompt": "Xoá Lệnh",
-        "addGlobalReferenceImage": "Thêm $t(controlLayers.globalReferenceImage)",
-        "referenceImageGlobal": "Ảnh Mẫu (Toàn Vùng)",
-        "sendingToCanvas": "Chuyển Ảnh Tạo Sinh Vào Canvas",
-        "sendingToGallery": "Chuyển Ảnh Tạo Sinh Vào Thư Viện Ảnh",
-        "sendToGallery": "Chuyển Tới Thư Viện Ảnh",
-        "sendToGalleryDesc": "Bấm 'Kích Hoạt' sẽ tiến hành tạo sinh và lưu ảnh vào thư viện ảnh.",
-        "newImg2ImgCanvasFromImage": "Chuyển Đổi Ảnh Sang Ảnh Mới Từ Ảnh",
-        "sendToCanvasDesc": "Bấm 'Kích Hoạt' sẽ hiển thị công việc đang xử lý của bạn lên canvas.",
-        "viewProgressInViewer": "Xem quá trình xử lý và ảnh đầu ra trong <Btn>Trình Xem Ảnh</Btn>.",
-        "viewProgressOnCanvas": "Xem quá trình xử lý và ảnh đầu ra trong <Btn>Canvas</Btn>.",
-        "globalReferenceImage_withCount_other": "$t(controlLayers.globalReferenceImage)",
-        "regionalGuidance_withCount_hidden": "Chỉ Dẫn Khu Vực ({{count}} đang ẩn)",
-        "controlLayers_withCount_hidden": "Layer Điều Khiển Được ({{count}} đang ẩn)",
-        "rasterLayers_withCount_hidden": "Layer Dạng Raster ({{count}} đang ẩn)",
-        "globalReferenceImages_withCount_hidden": "Ảnh Mẫu Toàn Vùng ({{count}} đang ẩn)",
-        "inpaintMasks_withCount_hidden": "Lớp Phủ Inpaint ({{count}} đang ẩn)",
-        "regionalGuidance_withCount_visible": "Chỉ Dẫn Khu Vực ({{count}})",
-        "controlLayers_withCount_visible": "Layer Điều Khiển Được ({{count}})",
-        "rasterLayers_withCount_visible": "Layer Dạng Raster ({{count}})",
-        "globalReferenceImages_withCount_visible": "Ảnh Mẫu Toàn Vùng ({{count}})",
-        "inpaintMasks_withCount_visible": "Lớp Phủ Inpaint ({{count}})",
-        "layer_withCount_other": "Layer ({{count}})",
-        "pastedTo": "Dán Vào {{destination}}",
-        "stagingOnCanvas": "Hiển thị hình ảnh lên",
-        "newGallerySession": "Phiên Thư Viện Ảnh Mới",
-        "newGallerySessionDesc": "Nó sẽ dọn sạch canvas và các thiết lập trừ model được chọn. Các ảnh được tạo sinh sẽ được chuyển đến thư viện ảnh.",
-        "newCanvasSession": "Phiên Canvas Mới",
-        "newCanvasSessionDesc": "Nó sẽ dọn sạch canvas và các thiết lập trừ model được chọn. Các ảnh được tạo sinh sẽ được chuyển đến canvas.",
-        "replaceCurrent": "Thay Đổi Cái Hiện Tại",
-        "uploadOrDragAnImage": "Kéo ảnh từ thư viện ảnh hoặc <UploadButton>tải lên ảnh</UploadButton>."
+        "useAsReferenceImage": "Dùng Làm Ảnh Mẫu"
     },
     "stylePresets": {
         "negativePrompt": "Lệnh Tiêu Cực",
@@ -2374,11 +2331,15 @@
     "toast": {
         "imageUploadFailed": "Tải Lên Ảnh Thất Bại",
         "layerCopiedToClipboard": "Sao Chép Layer Vào Clipboard",
+        "uploadFailedInvalidUploadDesc_withCount_other": "Tối đa là {{count}} ảnh PNG, JPEG hoặc WEBP.",
         "imageCopied": "Ảnh Đã Được Sao Chép",
         "sentToUpscale": "Chuyển Vào Upscale",
         "unableToLoadImage": "Không Thể Tải Hình Ảnh",
         "unableToLoadStylePreset": "Không Thể Tải Phong Cách Được Cài Đặt Trước",
         "stylePresetLoaded": "Phong Cách Được Cài Đặt Trước Đã Tải",
+        "imageNotLoadedDesc": "Không thể tìm thấy ảnh",
+        "imageSaved": "Ảnh Đã Lưu",
+        "imageSavingFailed": "Lưu Ảnh Thất Bại",
         "unableToLoadImageMetadata": "Không Thể Tải Metadata Của Ảnh",
         "workflowLoaded": "Workflow Đã Tải",
         "uploadFailed": "Tải Lên Thất Bại",
@@ -2390,14 +2351,17 @@
         "importFailed": "Nhập Vào Thất Bại",
         "importSuccessful": "Nhập Vào Thành Công",
         "workflowDeleted": "Workflow Đã Xoá",
+        "setControlImage": "Đặt làm ảnh điều khiển được",
         "connected": "Kết Nối Đến Server",
         "imageUploaded": "Ảnh Đã Được Tải Lên",
+        "invalidUpload": "Dữ Liệu Tải Lên Không Hợp Lệ",
         "modelImportCanceled": "Nhập Vào Model Thất Bại",
         "parameters": "Tham Số",
         "parameterSet": "Gợi Lại Tham Số",
         "parameterSetDesc": "Gợi lại {{parameter}}",
         "loadedWithWarnings": "Đã Tải Workflow Với Cảnh Báo",
         "outOfMemoryErrorDesc": "Thiết lập tạo sinh hiện tại đã vượt mức cho phép của thiết bị. Hãy điều chỉnh thiết lập và thử lại.",
+        "setNodeField": "Đặt làm vùng node",
         "problemRetrievingWorkflow": "Có Vấn Đề Khi Lấy Lại Workflow",
         "somethingWentWrong": "Có Vấn Đề Phát Sinh",
         "problemDeletingWorkflow": "Có Vấn Đề Khi Xoá Workflow",
@@ -2407,12 +2371,13 @@
         "errorCopied": "Lỗi Khi Sao Chép",
         "prunedQueue": "Cắt Bớt Hàng Đợi",
         "imagesWillBeAddedTo": "Ảnh đã tải lên sẽ được thêm vào tài nguyên của bảng {{boardName}}.",
-        "baseModelChangedCleared_other": "Cập nhật, dọn sạch hoặc tắt {{count}} model phụ không tương thích",
+        "baseModelChangedCleared_other": "Dọn sạch hoặc tắt {{count}} model phụ không tương thích",
         "canceled": "Quá Trình Xử Lý Đã Huỷ",
         "baseModelChanged": "Model Cơ Sở Đã Đổi",
         "addedToUncategorized": "Thêm vào tài nguyên của bảng $t(boards.uncategorized)",
         "linkCopied": "Đường Liên Kết Đã Được Sao Chép",
         "outOfMemoryError": "Lỗi Vượt Quá Bộ Nhớ",
+        "layerSavedToAssets": "Lưu Layer Vào Khu Tài Nguyên",
         "modelAddedSimple": "Đã Thêm Model Vào Hàng Đợi",
         "parametersSet": "Tham Số Đã Được Gợi Lại",
         "parameterNotSetDesc": "Không thể gợi lại {{parameter}}",
@@ -2433,15 +2398,21 @@
         "chatGPT4oIncompatibleGenerationMode": "ChatGPT 4o chỉ hỗ trợ Từ Ngữ Sang Hình Ảnh và Hình Ảnh Sang Hình Ảnh. Hãy dùng model khác cho các tác vụ Inpaint và Outpaint.",
         "imagenIncompatibleGenerationMode": "Google {{model}} chỉ hỗ trợ Từ Ngữ Sang Hình Ảnh. Dùng các model khác cho Hình Ảnh Sang Hình Ảnh, Inpaint và Outpaint.",
         "fluxKontextIncompatibleGenerationMode": "FLUX Kontext không hỗ trợ tạo sinh từ hình ảnh từ canvas. Thử sử dụng Ảnh Mẫu và tắt các Layer Dạng Raster.",
+        "noRasterLayers": "Không Tìm Thấy Layer Dạng Raster",
+        "noRasterLayersDesc": "Tạo ít nhất một layer dạng raster để xuất file PSD",
+        "noActiveRasterLayers": "Không Có Layer Dạng Raster Hoạt Động",
+        "noActiveRasterLayersDesc": "Khởi động ít nhất một layer dạng raster để xuất file PSD",
         "noVisibleRasterLayers": "Không Có Layer Dạng Raster Hiển Thị",
         "noVisibleRasterLayersDesc": "Khởi động ít nhất một layer dạng raster để xuất file PSD",
         "invalidCanvasDimensions": "Kích Thước Canvas Không Phù Hợp",
         "canvasTooLarge": "Canvas Quá Lớn",
         "canvasTooLargeDesc": "Kích thước canvas vượt mức tối đa cho phép để xuất file PSD. Giảm cả chiều dài và chiều rộng chủa canvas và thử lại.",
+        "failedToProcessLayers": "Thất Bại Khi Xử Lý Layer",
         "psdExportSuccess": "Xuất File PSD Hoàn Tất",
         "psdExportSuccessDesc": "Thành công xuất {{count}} layer sang file PSD",
         "problemExportingPSD": "Có Vấn Đề Khi Xuất File PSD",
         "canvasManagerNotAvailable": "Trình Quản Lý Canvas Không Có Sẵn",
+        "noValidLayerAdapters": "Không có Layer Adaper Phù Hợp",
         "promptGenerationStarted": "Trình tạo sinh lệnh khởi động",
         "uploadAndPromptGenerationFailed": "Thất bại khi tải lên ảnh để tạo sinh lệnh",
         "promptExpansionFailed": "Có vấn đề xảy ra. Hãy thử mở rộng lệnh lại.",
@@ -2449,20 +2420,6 @@
         "maskInvertFailed": "Thất Bại Khi Đảo Ngược Lớp Phủ",
         "noVisibleMasks": "Không Có Lớp Phủ Đang Hiển Thị",
         "noVisibleMasksDesc": "Tạo hoặc bật ít nhất một lớp phủ inpaint để đảo ngược",
-        "imageNotLoadedDesc": "Không thể tìm thấy ảnh",
-        "imageSaved": "Ảnh Đã Lưu",
-        "imageSavingFailed": "Lưu Ảnh Thất Bại",
-        "invalidUpload": "Dữ Liệu Tải Lên Không Hợp Lệ",
-        "layerSavedToAssets": "Lưu Layer Vào Khu Tài Nguyên",
-        "noRasterLayers": "Không Tìm Thấy Layer Dạng Raster",
-        "noRasterLayersDesc": "Tạo ít nhất một layer dạng raster để xuất file PSD",
-        "noActiveRasterLayers": "Không Có Layer Dạng Raster Hoạt Động",
-        "noActiveRasterLayersDesc": "Bật ít nhất một layer dạng raster để xuất file PSD",
-        "failedToProcessLayers": "Thất Bại Khi Xử Lý Layer",
-        "noValidLayerAdapters": "Không có Layer Adaper Phù Hợp",
-        "setControlImage": "Đặt làm ảnh điều khiển được",
-        "setNodeField": "Đặt làm vùng node",
-        "uploadFailedInvalidUploadDesc_withCount_other": "Cần tối đa {{count}} ảnh PNG, JPEG, hoặc WEBP.",
         "noInpaintMaskSelected": "Không Có Lớp Phủ Inpant Được Chọn",
         "noInpaintMaskSelectedDesc": "Chọn một lớp phủ inpaint để đảo ngược",
         "invalidBbox": "Hộp Giới Hạn Không Hợp Lệ",
@@ -2479,8 +2436,7 @@
             "queue": "Queue (Hàng Đợi)",
             "workflows": "Workflow (Luồng Làm Việc)",
             "workflowsTab": "$t(common.tab) $t(ui.tabs.workflows)",
-            "generate": "Tạo Sinh",
-            "video": "Video"
+            "generate": "Tạo Sinh"
         },
         "launchpad": {
             "workflowsTitle": "Đi sâu hơn với Workflow.",
@@ -2558,23 +2514,13 @@
             "generate": {
                 "canvasCalloutTitle": "Đang tìm cách để điều khiển, chỉnh sửa, và làm lại ảnh?",
                 "canvasCalloutLink": "Vào Canvas cho nhiều tính năng hơn."
-            },
-            "videoTitle": "Tạo sinh video từ lệnh chữ.",
-            "video": {
-                "startingFrameCalloutTitle": "Thêm Khung Hình Bắt Đầu",
-                "startingFrameCalloutDesc": "Thêm ảnh nhằm điều khiển khung hình đầu của video."
-            },
-            "addStartingFrame": {
-                "title": "Thêm Khung Hình Bắt Đầu",
-                "description": "Thêm ảnh nhằm điều khiển khung hình đầu của video."
             }
         },
         "panels": {
             "launchpad": "Launchpad",
             "workflowEditor": "Trình Biên Tập Workflow",
-            "imageViewer": "Trình Xem",
-            "canvas": "Canvas",
-            "video": "Video"
+            "imageViewer": "Trình Xem Ảnh",
+            "canvas": "Canvas"
         }
     },
     "workflows": {
@@ -2589,20 +2535,28 @@
         "saveWorkflowAs": "Lưu Workflow Như",
         "downloadWorkflow": "Lưu Vào Tệp",
         "noWorkflows": "Không Có Workflow",
+        "problemLoading": "Có Vấn Đề Khi Tải Workflow",
+        "clearWorkflowSearchFilter": "Xoá Workflow Khỏi Bộ Lọc Tìm Kiếm",
+        "defaultWorkflows": "Workflow Mặc Định",
+        "userWorkflows": "Workflow Của Người Dùng",
+        "projectWorkflows": "Dự Án Workflow",
         "savingWorkflow": "Đang Lưu Workflow...",
         "ascending": "Tăng Dần",
         "loading": "Đang Tải Workflow",
         "chooseWorkflowFromLibrary": "Chọn Workflow Từ Thư Viện",
         "workflows": "Workflow",
         "copyShareLinkForWorkflow": "Sao Chép Liên Kết Chia Sẻ Cho Workflow",
+        "openWorkflow": "Mở Workflow",
         "name": "Tên",
         "unnamedWorkflow": "Workflow Vô Danh",
         "saveWorkflow": "Lưu Workflow",
         "problemSavingWorkflow": "Có Vấn Đề Khi Lưu Workflow",
+        "noDescription": "Không có mô tả",
         "updated": "Đã Cập Nhật",
         "uploadWorkflow": "Tải Từ Tệp",
         "autoLayout": "Bố Trí Tự Động",
         "loadWorkflow": "$t(common.load) Workflow",
+        "searchWorkflows": "Tìm Workflow",
         "newWorkflowCreated": "Workflow Mới Được Tạo",
         "workflowCleared": "Đã Dọn Dẹp Workflow",
         "loadFromGraph": "Tải Workflow Từ Đồ Thị",
@@ -2613,6 +2567,7 @@
         "opened": "Đã Mở",
         "deleteWorkflow": "Xoá Workflow",
         "workflowEditorMenu": "Menu Biên Tập Workflow",
+        "openLibrary": "Mở Thư Viện",
         "builder": {
             "resetAllNodeFields": "Tải Lại Các Vùng Node",
             "builder": "Trình Tạo Vùng Nhập",
@@ -2628,6 +2583,7 @@
             "multiLine": "Nhiều Dòng",
             "slider": "Thanh Trượt",
             "both": "Cả Hai",
+            "emptyRootPlaceholderViewMode": "Chọn Chỉnh Sửa để bắt đầu tạo nên một vùng nhập cho workflow này.",
             "emptyRootPlaceholderEditMode": "Kéo thành phần vùng nhập hoặc vùng node vào đây để bắt đầu.",
             "containerPlaceholder": "Hộp Chứa Trống",
             "headingPlaceholder": "Đầu Dòng Trống",
@@ -2636,6 +2592,7 @@
             "deleteAllElements": "Xóa Tất Cả Thành Phần",
             "nodeField": "Vùng Node",
             "nodeFieldTooltip": "Để thêm vùng node, bấm vào dấu cộng nhỏ trên vùng trong Trình Biên Tập Workflow, hoặc kéo vùng theo tên của nó vào vùng nhập.",
+            "workflowBuilderAlphaWarning": "Trình tạo vùng nhập đang trong giai đoạn alpha. Nó có thể xuất hiện những thay đổi đột ngột trước khi chính thức được phát hành.",
             "container": "Hộp Chứa",
             "heading": "Đầu Dòng",
             "text": "Văn Bản",
@@ -2681,36 +2638,25 @@
             "errorWorkflowHasUnpublishableNodes": "Workflow có lô node, node sản sinh, hoặc node tách metadata",
             "removeFromForm": "Xóa Khỏi Vùng Nhập",
             "showShuffle": "Hiện Xáo Trộn",
-            "shuffle": "Xáo Trộn",
-            "emptyRootPlaceholderViewMode": "Chọn Chỉnh Sửa để bắt đầu tạo nên một vùng nhập cho workflow này.",
-            "workflowBuilderAlphaWarning": "Trình tạo vùng nhập đang trong giai đoạn alpha. Nó có thể xuất hiện những thay đổi đột ngột trước khi chính thức được phát hành."
+            "shuffle": "Xáo Trộn"
         },
         "yourWorkflows": "Workflow Của Bạn",
         "browseWorkflows": "Khám Phá Workflow",
         "workflowThumbnail": "Ảnh Minh Họa Workflow",
         "saveChanges": "Lưu Thay Đổi",
+        "allLoaded": "Đã Tải Tất Cả Workflow",
         "shared": "Nhóm",
         "searchPlaceholder": "Tìm theo tên, mô tả, hoặc nhãn",
+        "filterByTags": "Lọc Theo Nhãn",
         "recentlyOpened": "Mở Gần Đây",
         "private": "Cá Nhân",
         "loadMore": "Tải Thêm",
         "view": "Xem",
         "deselectAll": "Huỷ Chọn Tất Cả",
+        "noRecentWorkflows": "Không Có Workflows Gần Đây",
         "recommended": "Có Thể Bạn Sẽ Cần",
         "emptyStringPlaceholder": "<xâu ký tự trống>",
-        "published": "Đã Đăng",
-        "defaultWorkflows": "Workflow Mặc Định",
-        "userWorkflows": "Workflow Của Người Dùng",
-        "projectWorkflows": "Dự Án Workflow",
-        "allLoaded": "Đã Tải Tất Cả Workflow",
-        "filterByTags": "Lọc Theo Nhãn",
-        "noRecentWorkflows": "Không Có Workflows Gần Đây",
-        "openWorkflow": "Mở Workflow",
-        "problemLoading": "Có Vấn Đề Khi Tải Workflow",
-        "noDescription": "Không có mô tả",
-        "searchWorkflows": "Tìm Workflow",
-        "clearWorkflowSearchFilter": "Xoá Workflow Khỏi Bộ Lọc Tìm Kiếm",
-        "openLibrary": "Mở Thư Viện"
+        "published": "Đã Đăng"
     },
     "upscaling": {
         "missingUpscaleInitialImage": "Thiếu ảnh dùng để upscale",
@@ -2747,11 +2693,11 @@
         "whatsNewInInvoke": "Có Gì Mới Ở Invoke",
         "readReleaseNotes": "Đọc Ghi Chú Phát Hành",
         "watchRecentReleaseVideos": "Xem Video Phát Hành Mới Nhất",
+        "watchUiUpdatesOverview": "Xem Tổng Quan Về Những Cập Nhật Cho Giao Diện Người Dùng",
         "items": [
-            "Canvas: Chia tách màu nổi và màu nền - bật/tắt với 'x', khởi động lại về dạng đen trắng với 'd'",
-            "LoRA: Đặt khối lượng mặc định cho LoRA trong Trình Quản Lý Model"
-        ],
-        "watchUiUpdatesOverview": "Xem Tổng Quan Về Những Cập Nhật Cho Giao Diện Người Dùng"
+            "Misc QoL: Bật/Tắt hiển thị hộp giới hạn, đánh dấu node bị lỗi, chặn lỗi thêm node vào vùng nhập nhiều lần, khả năng đọc lại metadata của CLIP Skip",
+            "Giảm lượng tiêu thụ VRAM cho các ảnh mẫu Kontext và mã hóa VAE"
+        ]
     },
     "upsell": {
         "professional": "Chuyên Nghiệp",
@@ -2779,12 +2725,5 @@
         "clearSucceeded": "Cache Model Đã Được Dọn",
         "clearFailed": "Có Vấn Đề Khi Dọn Cache Model",
         "clear": "Dọn Cache Model"
-    },
-    "lora": {
-        "weight": "Trọng Lượng"
-    },
-    "video": {
-        "noVideoSelected": "Không có video được chọn",
-        "selectFromGallery": "Chọn một video trong thư viện để xem"
     }
 }

invokeai/frontend/web/public/locales/zh-CN.json

@@ -25,6 +25,7 @@
         "batch": "批次管理器",
         "communityLabel": "社区",
         "modelManager": "模型管理器",
+        "imageFailedToLoad": "无法加载图像",
         "learnMore": "了解更多",
         "advanced": "高级",
         "t2iAdapter": "T2I Adapter",
@@ -50,19 +51,23 @@
         "somethingWentWrong": "出了点问题",
         "copyError": "$t(gallery.copy) 错误",
         "input": "输入",
+        "notInstalled": "非 $t(common.installed)",
         "delete": "删除",
         "updated": "已上传",
         "save": "保存",
         "created": "已创建",
+        "prevPage": "上一页",
         "unknownError": "未知错误",
         "direction": "指向",
         "orderBy": "排序方式：",
+        "nextPage": "下一页",
         "saveAs": "保存为",
         "ai": "ai",
         "or": "或",
         "aboutDesc": "使用 Invoke 工作？来看看：",
         "add": "添加",
         "copy": "复制",
+        "localSystem": "本地系统",
         "aboutHeading": "掌握你的创造力",
         "enabled": "已启用",
         "disabled": "已禁用",
@@ -73,6 +78,7 @@
         "selected": "选中的",
         "green": "绿",
         "blue": "蓝",
+        "goTo": "前往",
         "dontShowMeThese": "请勿显示这些内容",
         "beta": "测试版",
         "toResolve": "解决",
@@ -98,11 +104,13 @@
         "galleryImageSize": "预览大小",
         "gallerySettings": "预览设置",
         "autoSwitchNewImages": "自动切换到新图像",
+        "noImagesInGallery": "无图像可用于显示",
         "deleteImage_other": "删除{{count}}张图片",
         "deleteImagePermanent": "删除的图片无法被恢复。",
         "autoAssignBoardOnClick": "点击后自动分配面板",
         "featuresWillReset": "如果您删除该图像，这些功能会立即被重置。",
         "loading": "加载中",
+        "unableToLoad": "无法加载图库",
         "currentlyInUse": "该图像目前在以下功能中使用：",
         "copy": "复制",
         "download": "下载",
@@ -117,6 +125,7 @@
         "starImage": "收藏图像",
         "alwaysShowImageSizeBadge": "始终显示图像尺寸",
         "selectForCompare": "选择以比较",
+        "selectAnImageToCompare": "选择一个图像进行比较",
         "slider": "滑块",
         "sideBySide": "并排",
         "bulkDownloadFailed": "下载失败",
@@ -139,6 +148,7 @@
         "newestFirst": "最新在前",
         "compareHelp4": "按 <Kbd>Z</Kbd>或 <Kbd>Esc</Kbd> 键退出。",
         "searchImages": "按元数据搜索",
+        "jump": "跳过",
         "compareHelp2": "按 <Kbd>M</Kbd> 键切换不同的比较模式。",
         "displayBoardSearch": "板块搜索",
         "displaySearch": "图像搜索",
@@ -151,6 +161,8 @@
         "gallery": "画廊",
         "move": "移动",
         "imagesTab": "您在Invoke中创建和保存的图片。",
+        "openViewer": "打开查看器",
+        "closeViewer": "关闭查看器",
         "assetsTab": "您已上传用于项目的文件。"
     },
     "hotkeys": {
@@ -561,7 +573,9 @@
         "huggingFacePlaceholder": "所有者或模型名称",
         "huggingFaceRepoID": "HuggingFace仓库ID",
         "loraTriggerPhrases": "LoRA 触发词",
+        "ipAdapters": "IP适配器",
         "spandrelImageToImage": "图生图(Spandrel)",
+        "starterModelsInModelManager": "您可以在模型管理器中找到初始模型",
         "noDefaultSettings": "此模型没有配置默认设置。请访问模型管理器添加默认设置。",
         "clipEmbed": "CLIP 嵌入",
         "defaultSettingsOutOfSync": "某些设置与模型的默认值不匹配：",
@@ -612,10 +626,12 @@
         "scaledHeight": "缩放长度",
         "infillMethod": "填充方法",
         "tileSize": "方格尺寸",
+        "downloadImage": "下载图像",
         "usePrompt": "使用提示",
         "useSeed": "使用种子",
         "useAll": "使用所有参数",
         "info": "信息",
+        "showOptionsPanel": "显示侧栏浮窗 (O 或 T)",
         "seamlessYAxis": "无缝平铺 Y 轴",
         "seamlessXAxis": "无缝平铺 X 轴",
         "denoisingStrength": "去噪强度",
@@ -641,11 +657,15 @@
             "addingImagesTo": "添加图像到",
             "noPrompts": "没有已生成的提示词",
             "canvasIsFiltering": "画布正在过滤",
+            "fluxModelIncompatibleScaledBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16)，缩放后的边界框高度为 {{height}}",
             "noCLIPEmbedModelSelected": "未为FLUX生成选择CLIP嵌入模型",
             "noFLUXVAEModelSelected": "未为FLUX生成选择VAE模型",
             "canvasIsRasterizing": "画布正在栅格化",
             "canvasIsCompositing": "画布正在合成",
+            "fluxModelIncompatibleBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16)，边界框宽度为 {{width}}",
+            "fluxModelIncompatibleScaledBboxWidth": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16)，缩放后的边界框宽度为 {{width}}",
             "noT5EncoderModelSelected": "未为FLUX生成选择T5编码器模型",
+            "fluxModelIncompatibleBboxHeight": "$t(parameters.invoke.fluxRequiresDimensionsToBeMultipleOf16)，边界框高度为 {{height}}",
             "canvasIsTransforming": "画布正在变换"
         },
         "patchmatchDownScaleSize": "缩小",
@@ -709,6 +729,8 @@
         "informationalPopoversDisabledDesc": "信息提示框已被禁用.请在设置中重新启用.",
         "enableModelDescriptions": "在下拉菜单中启用模型描述",
         "confirmOnNewSession": "新会话时确认",
+        "modelDescriptionsDisabledDesc": "下拉菜单中的模型描述已被禁用。可在设置中启用。",
+        "modelDescriptionsDisabled": "下拉菜单中的模型描述已禁用",
         "showDetailedInvocationProgress": "显示进度详情"
     },
     "toast": {
@@ -724,11 +746,14 @@
         "problemCopyingImage": "无法复制图像",
         "modelAddedSimple": "模型已加入队列",
         "loadedWithWarnings": "已加载带有警告的工作流",
+        "setControlImage": "设为控制图像",
+        "setNodeField": "设为节点字段",
         "imageUploaded": "图像已上传",
         "addedToBoard": "添加到{{name}}的资产中",
         "workflowLoaded": "工作流已加载",
         "imageUploadFailed": "图像上传失败",
         "baseModelChangedCleared_other": "已清除或禁用{{count}}个不兼容的子模型",
+        "invalidUpload": "无效的上传",
         "problemDeletingWorkflow": "删除工作流时出现问题",
         "workflowDeleted": "已删除工作流",
         "problemRetrievingWorkflow": "检索工作流时发生问题",
@@ -748,16 +773,21 @@
         "modelImportCanceled": "模型导入已取消",
         "importFailed": "导入失败",
         "importSuccessful": "导入成功",
+        "layerSavedToAssets": "图层已保存到资产",
         "sentToUpscale": "已发送到放大处理",
         "addedToUncategorized": "已添加到看板 $t(boards.uncategorized) 的资产中",
         "linkCopied": "链接已复制",
+        "uploadFailedInvalidUploadDesc_withCount_other": "最多只能上传 {{count}} 张 PNG 或 JPEG 图像。",
         "problemSavingLayer": "无法保存图层",
         "unableToLoadImage": "无法加载图像",
+        "imageNotLoadedDesc": "无法找到图像",
         "unableToLoadStylePreset": "无法加载样式预设",
         "stylePresetLoaded": "样式预设已加载",
         "problemCopyingLayer": "无法复制图层",
         "sentToCanvas": "已发送到画布",
         "unableToLoadImageMetadata": "无法加载图像元数据",
+        "imageSaved": "图像已保存",
+        "imageSavingFailed": "图像保存失败",
         "layerCopiedToClipboard": "图层已复制到剪贴板",
         "imagesWillBeAddedTo": "上传的图像将添加到看板 {{boardName}} 的资产中。"
     },
@@ -785,8 +815,11 @@
         "fitViewportNodes": "自适应视图",
         "showMinimapnodes": "显示缩略图",
         "hideMinimapnodes": "隐藏缩略图",
+        "showLegendNodes": "显示字段类型图例",
+        "hideLegendNodes": "隐藏字段类型图例",
         "downloadWorkflow": "下载工作流 JSON",
         "workflowDescription": "简述",
+        "versionUnknown": " 未知版本",
         "noNodeSelected": "无选中的节点",
         "addNode": "添加节点",
         "unableToValidateWorkflow": "无法验证工作流",
@@ -796,7 +829,9 @@
         "workflowContact": "联系",
         "animatedEdges": "边缘动效",
         "nodeTemplate": "节点模板",
+        "unableToLoadWorkflow": "无法加载工作流",
         "snapToGrid": "对齐网格",
+        "noFieldsLinearview": "线性视图中未添加任何字段",
         "nodeSearch": "检索节点",
         "version": "版本",
         "validateConnections": "验证连接和节点图",
@@ -811,6 +846,8 @@
         "fieldTypesMustMatch": "类型必须匹配",
         "workflow": "工作流",
         "animatedEdgesHelp": "为选中边缘和其连接的选中节点的边缘添加动画",
+        "unknownTemplate": "未知模板",
+        "removeLinearView": "从线性视图中移除",
         "workflowTags": "标签",
         "fullyContainNodesHelp": "节点必须完全位于选择框中才能被选中",
         "workflowValidation": "工作流验证错误",
@@ -844,6 +881,7 @@
         "node": "节点",
         "collection": "合集",
         "string": "字符串",
+        "mismatchedVersion": "无效的节点：类型为 {{type}} 的节点 {{node}} 版本不匹配（是否尝试更新？）",
         "cannotDuplicateConnection": "无法创建重复的连接",
         "enum": "Enum (枚举)",
         "float": "浮点",
@@ -854,6 +892,7 @@
         "unableToUpdateNodes_other": "{{count}} 个节点无法完成更新",
         "inputFieldTypeParseError": "无法解析 {{node}} 的输入类型 {{field}}。({{message}})",
         "unsupportedArrayItemType": "不支持的数组类型 \"{{type}}\"",
+        "addLinearView": "添加到线性视图",
         "targetNodeFieldDoesNotExist": "无效的边缘：{{node}} 的目标/输入区域 {{field}} 不存在",
         "unsupportedMismatchedUnion": "合集或标量类型与基类 {{firstType}} 和 {{secondType}} 不匹配",
         "allNodesUpdated": "已更新所有节点",
@@ -873,6 +912,7 @@
         "collectionOrScalarFieldType": "{{name}} (单一项目或项目集合)",
         "nodeVersion": "节点版本",
         "deletedInvalidEdge": "已删除无效的边缘 {{source}} -> {{target}}",
+        "unknownInput": "未知输入：{{name}}",
         "prototypeDesc": "此调用是一个原型 (prototype)。它可能会在本项目更新期间发生破坏性更改，并且随时可能被删除。",
         "betaDesc": "此调用尚处于测试阶段。在稳定之前，它可能会在项目更新期间发生破坏性更改。本项目计划长期支持这种调用。",
         "newWorkflow": "新建工作流",
@@ -884,6 +924,7 @@
         "missingNode": "缺少调用节点",
         "missingInvocationTemplate": "缺少调用模版",
         "noFieldsViewMode": "此工作流程未选择任何要显示的字段.请查看完整工作流程以进行配置.",
+        "reorderLinearView": "调整线性视图顺序",
         "viewMode": "在线性视图中使用",
         "showEdgeLabelsHelp": "在边缘上显示标签，指示连接的节点",
         "cannotMixAndMatchCollectionItemTypes": "集合项目类型不能混用",
@@ -957,6 +998,7 @@
         "session": "会话",
         "enqueueing": "队列中的批次",
         "graphFailedToQueue": "节点图加入队列失败",
+        "batchFieldValues": "批处理值",
         "time": "时间",
         "openQueue": "打开队列",
         "prompts_other": "提示词",
@@ -975,14 +1017,18 @@
         "refinerStart": "Refiner 开始作用时机",
         "scheduler": "调度器",
         "cfgScale": "CFG 等级",
+        "negStylePrompt": "负向样式提示词",
         "noModelsAvailable": "无可用模型",
         "negAestheticScore": "负向美学评分",
         "denoisingStrength": "去噪强度",
         "refinermodel": "Refiner 模型",
         "posAestheticScore": "正向美学评分",
+        "concatPromptStyle": "链接提示词 & 样式",
         "loading": "加载中...",
         "steps": "步数",
+        "posStylePrompt": "正向样式提示词",
         "refiner": "Refiner",
+        "freePromptStyle": "手动输入样式提示词",
         "refinerSteps": "精炼步数"
     },
     "metadata": {
@@ -1009,6 +1055,8 @@
         "vae": "VAE",
         "cfgRescaleMultiplier": "$t(parameters.cfgRescaleMultiplier)",
         "allPrompts": "所有提示",
+        "parsingFailed": "解析失败",
+        "recallParameter": "调用{{label}}",
         "imageDimensions": "图像尺寸",
         "parameterSet": "已设置参数{{parameter}}",
         "guidance": "指导",
@@ -1019,9 +1067,11 @@
     "models": {
         "noMatchingModels": "无相匹配的模型",
         "loading": "加载中",
+        "noMatchingLoRAs": "无相匹配的 LoRA",
         "noModelsAvailable": "无可用模型",
         "selectModel": "选择一个模型",
         "noRefinerModelsInstalled": "无已安装的 SDXL Refiner 模型",
+        "noLoRAsInstalled": "无已安装的 LoRA",
         "addLora": "添加 LoRA",
         "lora": "LoRA",
         "defaultVAE": "默认 VAE",
@@ -1050,8 +1100,10 @@
         "deletedBoardsCannotbeRestored": "删除的面板无法恢复。选择“仅删除面板”选项后，相关图片将会被移至未分类区域。",
         "movingImagesToBoard_other": "移动 {{count}} 张图像到面板：",
         "selectedForAutoAdd": "已选中自动添加",
+        "hideBoards": "隐藏面板",
         "noBoards": "没有{{boardType}}类型的面板",
         "unarchiveBoard": "恢复面板",
+        "viewBoards": "查看面板",
         "addPrivateBoard": "创建私密面板",
         "addSharedBoard": "创建共享面板",
         "boards": "面板",
@@ -1520,6 +1572,8 @@
         "useCache": "使用缓存"
     },
     "hrf": {
+        "enableHrf": "启用高分辨率修复",
+        "upscaleMethod": "放大方法",
         "metadata": {
             "strength": "高分辨率修复强度",
             "enabled": "高分辨率修复已启用",
@@ -1532,15 +1586,20 @@
         "workflowEditorMenu": "工作流编辑器菜单",
         "workflowName": "工作流名称",
         "saveWorkflow": "保存工作流",
+        "openWorkflow": "打开工作流",
+        "clearWorkflowSearchFilter": "清除工作流检索过滤器",
         "workflowLibrary": "工作流库",
         "downloadWorkflow": "保存到文件",
         "workflowSaved": "已保存工作流",
         "unnamedWorkflow": "未命名的工作流",
         "savingWorkflow": "保存工作流中...",
+        "problemLoading": "加载工作流时出现问题",
         "loading": "加载工作流中",
+        "searchWorkflows": "检索工作流",
         "problemSavingWorkflow": "保存工作流时出现问题",
         "deleteWorkflow": "删除工作流",
         "workflows": "工作流",
+        "noDescription": "无描述",
         "uploadWorkflow": "从文件中加载",
         "newWorkflowCreated": "已创建新的工作流",
         "name": "名称",
@@ -1560,6 +1619,9 @@
         "copyShareLinkForWorkflow": "复制工作流程的分享链接",
         "delete": "删除",
         "download": "下载",
+        "defaultWorkflows": "默认工作流程",
+        "userWorkflows": "用户工作流程",
+        "projectWorkflows": "项目工作流程",
         "copyShareLink": "复制分享链接",
         "chooseWorkflowFromLibrary": "从库中选择工作流程",
         "deleteWorkflow2": "您确定要删除此工作流程吗？此操作无法撤销。"
@@ -1597,6 +1659,7 @@
         "moveToBack": "移动到后面",
         "moveToFront": "移动到前面",
         "addLayer": "添加层",
+        "deletePrompt": "删除提示词",
         "addPositivePrompt": "添加 $t(controlLayers.prompt)",
         "addNegativePrompt": "添加 $t(controlLayers.negativePrompt)",
         "rectangle": "矩形",
@@ -1620,6 +1683,7 @@
         "maskFill": "遮罩填充",
         "newCanvasFromImage": "从图像创建新画布",
         "pullBboxIntoReferenceImageOk": "边界框已导入到参考图像",
+        "globalReferenceImage_withCount_other": "全局参考图像",
         "addInpaintMask": "添加 $t(controlLayers.inpaintMask)",
         "referenceImage": "参考图像",
         "globalReferenceImage": "全局参考图像",
@@ -1628,10 +1692,14 @@
         "copyRasterLayerTo": "复制 $t(controlLayers.rasterLayer) 到",
         "clearHistory": "清除历史记录",
         "inpaintMask": "修复遮罩",
+        "regionalGuidance_withCount_visible": "区域引导（{{count}} 个）",
+        "inpaintMasks_withCount_hidden": "修复遮罩（{{count}} 个已隐藏）",
         "enableAutoNegative": "启用自动负面提示",
         "disableAutoNegative": "禁用自动负面提示",
         "deleteReferenceImage": "删除参考图像",
         "sendToCanvas": "发送到画布",
+        "controlLayers_withCount_visible": "控制图层（{{count}} 个）",
+        "rasterLayers_withCount_visible": "栅格图层（{{count}} 个）",
         "convertRegionalGuidanceTo": "将 $t(controlLayers.regionalGuidance) 转换为",
         "newInpaintMask": "新建 $t(controlLayers.inpaintMask)",
         "regionIsEmpty": "选定区域为空",
@@ -1643,12 +1711,14 @@
         "addRasterLayer": "添加 $t(controlLayers.rasterLayer)",
         "newRasterLayerOk": "已创建栅格层",
         "newRasterLayerError": "创建栅格层时出现问题",
+        "inpaintMasks_withCount_visible": "修复遮罩（{{count}} 个）",
         "convertRasterLayerTo": "将 $t(controlLayers.rasterLayer) 转换为",
         "copyControlLayerTo": "复制 $t(controlLayers.controlLayer) 到",
         "copyInpaintMaskTo": "复制 $t(controlLayers.inpaintMask) 到",
         "copyRegionalGuidanceTo": "复制 $t(controlLayers.regionalGuidance) 到",
         "newRasterLayer": "新建 $t(controlLayers.rasterLayer)",
         "newControlLayer": "新建 $t(controlLayers.controlLayer)",
+        "newImg2ImgCanvasFromImage": "从图像创建新的图生图",
         "rasterLayer": "栅格层",
         "controlLayer": "控制层",
         "outputOnlyMaskedRegions": "仅输出生成的区域",
@@ -1661,22 +1731,36 @@
         "bboxOverlay": "显示边界框覆盖层",
         "clipToBbox": "将Clip限制到边界框",
         "width": "宽度",
+        "addGlobalReferenceImage": "添加 $t(controlLayers.globalReferenceImage)",
         "inpaintMask_withCount_other": "修复遮罩",
         "regionalGuidance_withCount_other": "区域引导",
         "newRegionalReferenceImageError": "创建局部参考图像时出现问题",
         "pullBboxIntoLayerError": "将边界框导入图层时出现问题",
         "pullBboxIntoLayerOk": "边界框已导入到图层",
+        "sendToCanvasDesc": "按下“Invoke”按钮会将您的工作进度暂存到画布上。",
+        "sendToGallery": "发送到图库",
+        "sendToGalleryDesc": "按下“Invoke”键会生成并保存一张唯一的图像到您的图库中。",
         "rasterLayer_withCount_other": "栅格图层",
         "mergeDown": "向下合并",
         "clearCaches": "清除缓存",
         "recalculateRects": "重新计算矩形",
         "duplicate": "复制",
+        "regionalGuidance_withCount_hidden": "区域引导（{{count}} 个已隐藏）",
         "convertControlLayerTo": "将 $t(controlLayers.controlLayer) 转换为",
         "convertInpaintMaskTo": "将 $t(controlLayers.inpaintMask) 转换为",
+        "viewProgressInViewer": "在 <Btn>图像查看器</Btn> 中查看进度和输出结果。",
+        "viewProgressOnCanvas": "在 <Btn>画布</Btn> 上查看进度和暂存的输出内容。",
+        "sendingToGallery": "将生成内容发送到图库",
         "copyToClipboard": "复制到剪贴板",
         "controlLayer_withCount_other": "控制图层",
+        "sendingToCanvas": "在画布上准备生成",
         "addReferenceImage": "添加 $t(controlLayers.referenceImage)",
         "addRegionalGuidance": "添加 $t(controlLayers.regionalGuidance)",
+        "controlLayers_withCount_hidden": "控制图层（{{count}} 个已隐藏）",
+        "rasterLayers_withCount_hidden": "栅格图层（{{count}} 个已隐藏）",
+        "globalReferenceImages_withCount_hidden": "全局参考图像（{{count}} 个已隐藏）",
+        "globalReferenceImages_withCount_visible": "全局参考图像（{{count}} 个）",
+        "layer_withCount_other": "图层（{{count}} 个）",
         "enableTransparencyEffect": "启用透明效果",
         "disableTransparencyEffect": "禁用透明效果",
         "hidingType": "隐藏 {{type}}",

invokeai/frontend/web/public/locales/zh-Hant.json

@@ -19,6 +19,7 @@
         "folder": "資料夾",
         "installed": "已安裝",
         "accept": "接受",
+        "goTo": "前往",
         "input": "輸入",
         "random": "隨機",
         "selected": "已選擇",
@@ -28,7 +29,8 @@
         "copy": "複製",
         "error": "錯誤",
         "file": "檔案",
-        "format": "格式"
+        "format": "格式",
+        "imageFailedToLoad": "無法載入圖片"
     },
     "accessibility": {
         "invokeProgressBar": "Invoke 進度條",
@@ -177,7 +179,8 @@
         "workflowAuthor": "作者",
         "version": "版本",
         "executionStateCompleted": "已完成",
-        "edge": "邊緣"
+        "edge": "邊緣",
+        "versionUnknown": " 版本未知"
     },
     "sdxl": {
         "steps": "步數",

invokeai/frontend/web/src/app/components/GlobalModalIsolator.tsx

@@ -1,8 +1,6 @@
 import { GlobalImageHotkeys } from 'app/components/GlobalImageHotkeys';
 import ChangeBoardModal from 'features/changeBoardModal/components/ChangeBoardModal';
 import { CanvasPasteModal } from 'features/controlLayers/components/CanvasPasteModal';
-import { CanvasManagerProviderGate } from 'features/controlLayers/contexts/CanvasManagerProviderGate';
-import { CropImageModal } from 'features/cropper/components/CropImageModal';
 import { DeleteImageModal } from 'features/deleteImageModal/components/DeleteImageModal';
 import { DeleteVideoModal } from 'features/deleteVideoModal/components/DeleteVideoModal';
 import { FullscreenDropzone } from 'features/dnd/FullscreenDropzone';
@@ -55,11 +53,8 @@ export const GlobalModalIsolator = memo(() => {
       <FullscreenDropzone />
       <VideosModal />
       <SaveWorkflowAsDialog />
-      <CanvasManagerProviderGate>
-        <CanvasPasteModal />
-      </CanvasManagerProviderGate>
+      <CanvasPasteModal />
       <LoadWorkflowFromGraphModal />
-      <CropImageModal />
     </>
   );
 });

invokeai/frontend/web/src/app/hooks/useStudioInitAction.ts

@@ -3,7 +3,8 @@ import { useAppStore } from 'app/store/storeHooks';
 import { useAssertSingleton } from 'common/hooks/useAssertSingleton';
 import { withResultAsync } from 'common/util/result';
 import { canvasReset } from 'features/controlLayers/store/actions';
-import { rasterLayerAdded } from 'features/controlLayers/store/canvasSlice';
+import { instanceActions } from 'features/controlLayers/store/canvasInstanceSlice';
+import { paramsReset } from 'features/controlLayers/store/paramsSlice';
 import type { CanvasRasterLayerState } from 'features/controlLayers/store/types';
 import { imageDTOToImageObject } from 'features/controlLayers/store/util';
 import { sentImageToCanvas } from 'features/gallery/store/actions';
@@ -93,7 +94,7 @@ export const useStudioInitAction = (action?: StudioInitAction) => {
       };
       await navigationApi.focusPanel('canvas', WORKSPACE_PANEL_ID);
       store.dispatch(canvasReset());
-      store.dispatch(rasterLayerAdded({ overrides, isSelected: true }));
+      store.dispatch(instanceActions.rasterLayerAdded({ overrides, isSelected: true }));
       store.dispatch(sentImageToCanvas());
       toast({
         title: t('toast.sentToCanvas'),
@@ -163,6 +164,7 @@ export const useStudioInitAction = (action?: StudioInitAction) => {
         case 'generation':
           // Go to the generate tab, open the launchpad
           await navigationApi.focusPanel('generate', LAUNCHPAD_PANEL_ID);
+          store.dispatch(paramsReset());
           break;
         case 'canvas':
           // Go to the canvas tab, open the launchpad

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardAndImagesDeleted.ts

@@ -24,6 +24,9 @@ export const addDeleteBoardAndImagesFulfilledListener = (startAppListening: AppS
       const refImages = selectRefImagesSlice(state);
 
       deleted_images.forEach((image_name) => {
+        if (!canvas) {
+          return;
+        }
         const imageUsage = getImageUsage(nodes, canvas, upscale, refImages, image_name);
 
         if (imageUsage.isNodesImage && !wasNodeEditorReset) {

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardIdSelected.ts

@@ -48,8 +48,6 @@ export const addBoardIdSelectedListener = (startAppListening: AppStartListening)
 
         if (imageToSelect) {
           dispatch(itemSelected({ type: 'image', id: imageToSelect }));
-        } else {
-          dispatch(itemSelected(null));
         }
       } else {
         const queryArgs = { ...selectGetVideoIdsQueryArgs(state), board_id };
@@ -72,8 +70,6 @@ export const addBoardIdSelectedListener = (startAppListening: AppStartListening)
 
         if (videoToSelect) {
           dispatch(itemSelected({ type: 'video', id: videoToSelect }));
-        } else {
-          dispatch(itemSelected(null));
         }
       }
     },

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/modelSelected.ts

@@ -1,6 +1,6 @@
 import { logger } from 'app/logging/logger';
 import type { AppStartListening } from 'app/store/store';
-import { bboxSyncedToOptimalDimension, rgRefImageModelChanged } from 'features/controlLayers/store/canvasSlice';
+import { bboxSyncedToOptimalDimension, rgRefImageModelChanged } from 'features/controlLayers/store/canvasInstanceSlice';
 import { buildSelectIsStaging, selectCanvasSessionId } from 'features/controlLayers/store/canvasStagingAreaSlice';
 import { loraIsEnabledChanged } from 'features/controlLayers/store/lorasSlice';
 import { modelChanged, syncedToOptimalDimension, vaeSelected } from 'features/controlLayers/store/paramsSlice';
@@ -119,6 +119,9 @@ export const addModelSelectedListener = (startAppListening: AppStartListening) =
 
         // All regional guidance entities are updated to use the same new model.
         const canvasState = selectCanvasSlice(state);
+        if (!canvasState) {
+          return;
+        }
         const canvasRegionalGuidanceEntities = selectAllEntitiesOfType(canvasState, 'regional_guidance');
         for (const entity of canvasRegionalGuidanceEntities) {
           for (const refImage of entity.referenceImages) {

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/modelsLoaded.ts

@@ -1,6 +1,6 @@
 import { logger } from 'app/logging/logger';
 import type { AppDispatch, AppStartListening, RootState } from 'app/store/store';
-import { controlLayerModelChanged, rgRefImageModelChanged } from 'features/controlLayers/store/canvasSlice';
+import { controlLayerModelChanged, rgRefImageModelChanged } from 'features/controlLayers/store/canvasInstanceSlice';
 import { loraDeleted } from 'features/controlLayers/store/lorasSlice';
 import {
   clipEmbedModelSelected,
@@ -12,13 +12,7 @@ import {
 } from 'features/controlLayers/store/paramsSlice';
 import { refImageModelChanged, selectRefImagesSlice } from 'features/controlLayers/store/refImagesSlice';
 import { selectCanvasSlice } from 'features/controlLayers/store/selectors';
-import {
-  getEntityIdentifier,
-  isFLUXReduxConfig,
-  isIPAdapterConfig,
-  isRegionalGuidanceFLUXReduxConfig,
-  isRegionalGuidanceIPAdapterConfig,
-} from 'features/controlLayers/store/types';
+import { getEntityIdentifier, isFLUXReduxConfig, isIPAdapterConfig } from 'features/controlLayers/store/types';
 import { zModelIdentifierField } from 'features/nodes/types/common';
 import { modelSelected } from 'features/parameters/store/actions';
 import {
@@ -221,7 +215,11 @@ const handleVideoModels: ModelHandler = (models, state, dispatch, log) => {
 
 const handleControlAdapterModels: ModelHandler = (models, state, dispatch, log) => {
   const caModels = models.filter(isControlLayerModelConfig);
-  selectCanvasSlice(state).controlLayers.entities.forEach((entity) => {
+  const canvas = selectCanvasSlice(state);
+  if (!canvas) {
+    return;
+  }
+  canvas.controlLayers.entities.forEach((entity) => {
     const selectedControlAdapterModel = entity.controlAdapter.model;
     // `null` is a valid control adapter model - no need to do anything.
     if (!selectedControlAdapterModel) {
@@ -256,9 +254,13 @@ const handleIPAdapterModels: ModelHandler = (models, state, dispatch, log) => {
     dispatch(refImageModelChanged({ id: entity.id, modelConfig: null }));
   });
 
-  selectCanvasSlice(state).regionalGuidance.entities.forEach((entity) => {
+  const canvas2 = selectCanvasSlice(state);
+  if (!canvas2) {
+    return;
+  }
+  canvas2.regionalGuidance.entities.forEach((entity) => {
     entity.referenceImages.forEach(({ id: referenceImageId, config }) => {
-      if (!isRegionalGuidanceIPAdapterConfig(config)) {
+      if (!isIPAdapterConfig(config)) {
         return;
       }
 
@@ -299,9 +301,13 @@ const handleFLUXReduxModels: ModelHandler = (models, state, dispatch, log) => {
     dispatch(refImageModelChanged({ id: entity.id, modelConfig: null }));
   });
 
-  selectCanvasSlice(state).regionalGuidance.entities.forEach((entity) => {
+  const canvas3 = selectCanvasSlice(state);
+  if (!canvas3) {
+    return;
+  }
+  canvas3.regionalGuidance.entities.forEach((entity) => {
     entity.referenceImages.forEach(({ id: referenceImageId, config }) => {
-      if (!isRegionalGuidanceFLUXReduxConfig(config)) {
+      if (!isFLUXReduxConfig(config)) {
         return;
       }
 

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/setDefaultSettings.ts

@@ -1,6 +1,6 @@
 import type { AppStartListening } from 'app/store/store';
 import { isNil } from 'es-toolkit';
-import { bboxHeightChanged, bboxWidthChanged } from 'features/controlLayers/store/canvasSlice';
+import { bboxHeightChanged, bboxWidthChanged } from 'features/controlLayers/store/canvasInstanceSlice';
 import { buildSelectIsStaging, selectCanvasSessionId } from 'features/controlLayers/store/canvasStagingAreaSlice';
 import {
   heightChanged,

invokeai/frontend/web/src/app/store/migrations/canvasMigration.ts

@@ -0,0 +1,85 @@
+import { nanoid } from '@reduxjs/toolkit';
+import type { CanvasState } from 'features/controlLayers/store/types';
+import { getInitialCanvasState } from 'features/controlLayers/store/types';
+import type { StateWithHistory } from 'redux-undo';
+
+// Type alias for backward compatibility
+type Undoable<T> = StateWithHistory<T>;
+
+/**
+ * Migration from single canvas (v1) to multi-canvas (v2) state structure.
+ * 
+ * This migration wraps the existing canvas state in the new instances structure:
+ * - Creates a new canvases slice with instances dictionary
+ * - Wraps the old canvas state in an Undoable structure
+ * - Sets the first instance as active
+ * 
+ * Before: { canvas: { present: CanvasState, past: [], future: [] }, ... }
+ * After: { canvases: { instances: { [id]: { present: CanvasState, past: [], future: [] } }, activeInstanceId: id }, ... }
+ */
+export const migrateCanvasV1ToV2 = (state: any) => {
+  // Check if we have old canvas state but no canvases state
+  if (state.canvas && !state.canvases) {
+    const canvasId = nanoid();
+    
+    // The canvas state is already undoable, so we can use it directly
+    const undoableState: Undoable<CanvasState> = state.canvas;
+    
+    // Remove the old canvas state and replace with new structure
+    const { canvas: _oldCanvas, ...restState } = state;
+    
+    return {
+      ...restState,
+      canvases: {
+        instances: {
+          [canvasId]: undoableState
+        },
+        activeInstanceId: canvasId
+      }
+    };
+  }
+  
+  return state;
+};
+
+/**
+ * Migration helper to ensure backward compatibility.
+ * This can be used in the persist config of the canvases slice.
+ */
+export const migrateCanvasState = (state: any, version?: number) => {
+  // Apply v1 to v2 migration if needed
+  let migratedState = migrateCanvasV1ToV2(state);
+  
+  // Future migrations can be added here
+  // if (version < 3) {
+  //   migratedState = migrateV2ToV3(migratedState);
+  // }
+  
+  return migratedState;
+};
+
+/**
+ * Helper to check if the state needs migration
+ */
+export const needsCanvasMigration = (state: any): boolean => {
+  return Boolean(state.canvas && !state.canvases);
+};
+
+/**
+ * Creates a default canvas instance for new installations
+ */
+export const createDefaultCanvasInstance = (): { instances: Record<string, Undoable<CanvasState>>, activeInstanceId: string } => {
+  const canvasId = nanoid();
+  return {
+    instances: {
+      [canvasId]: {
+        past: [],
+        present: getInitialCanvasState(), // This will need to be imported
+        future: []
+      }
+    },
+    activeInstanceId: canvasId
+  };
+};
+
+// Note: getInitialCanvasState is now imported from types

invokeai/frontend/web/src/app/store/nanostores/authToken.ts

@@ -1,11 +1,6 @@
-import { atom, computed } from 'nanostores';
+import { atom } from 'nanostores';
 
 /**
  * The user's auth token.
  */
 export const $authToken = atom<string | undefined>();
-
-/**
- * The crossOrigin value to use for all image loading. Depends on whether the user is authenticated.
- */
-export const $crossOrigin = computed($authToken, (token) => (token ? 'use-credentials' : 'anonymous'));

invokeai/frontend/web/src/app/store/store.ts

@@ -18,11 +18,10 @@ import { addModelsLoadedListener } from 'app/store/middleware/listenerMiddleware
 import { addSetDefaultSettingsListener } from 'app/store/middleware/listenerMiddleware/listeners/setDefaultSettings';
 import { addSocketConnectedEventListener } from 'app/store/middleware/listenerMiddleware/listeners/socketConnected';
 import { deepClone } from 'common/util/deepClone';
-import { merge } from 'es-toolkit';
-import { omit, pick } from 'es-toolkit/compat';
+import { keys, mergeWith, omit, pick } from 'es-toolkit/compat';
 import { changeBoardModalSliceConfig } from 'features/changeBoardModal/store/slice';
+import { canvasesSliceConfig } from 'features/controlLayers/store/canvasesSlice';
 import { canvasSettingsSliceConfig } from 'features/controlLayers/store/canvasSettingsSlice';
-import { canvasSliceConfig } from 'features/controlLayers/store/canvasSlice';
 import { canvasSessionSliceConfig } from 'features/controlLayers/store/canvasStagingAreaSlice';
 import { lorasSliceConfig } from 'features/controlLayers/store/lorasSlice';
 import { paramsSliceConfig } from 'features/controlLayers/store/paramsSlice';
@@ -65,7 +64,7 @@ const log = logger('system');
 const SLICE_CONFIGS = {
   [canvasSessionSliceConfig.slice.reducerPath]: canvasSessionSliceConfig,
   [canvasSettingsSliceConfig.slice.reducerPath]: canvasSettingsSliceConfig,
-  [canvasSliceConfig.slice.reducerPath]: canvasSliceConfig,
+  [canvasesSliceConfig.slice.reducerPath]: canvasesSliceConfig,
   [changeBoardModalSliceConfig.slice.reducerPath]: changeBoardModalSliceConfig,
   [configSliceConfig.slice.reducerPath]: configSliceConfig,
   [dynamicPromptsSliceConfig.slice.reducerPath]: dynamicPromptsSliceConfig,
@@ -91,11 +90,8 @@ const ALL_REDUCERS = {
   [api.reducerPath]: api.reducer,
   [canvasSessionSliceConfig.slice.reducerPath]: canvasSessionSliceConfig.slice.reducer,
   [canvasSettingsSliceConfig.slice.reducerPath]: canvasSettingsSliceConfig.slice.reducer,
-  // Undoable!
-  [canvasSliceConfig.slice.reducerPath]: undoable(
-    canvasSliceConfig.slice.reducer,
-    canvasSliceConfig.undoableConfig?.reduxUndoOptions
-  ),
+  // No longer undoable here - canvasesSlice manages its own undoable instances
+  [canvasesSliceConfig.slice.reducerPath]: canvasesSliceConfig.slice.reducer,
   [changeBoardModalSliceConfig.slice.reducerPath]: changeBoardModalSliceConfig.slice.reducer,
   [configSliceConfig.slice.reducerPath]: configSliceConfig.slice.reducer,
   [dynamicPromptsSliceConfig.slice.reducerPath]: dynamicPromptsSliceConfig.slice.reducer,
@@ -134,14 +130,16 @@ const unserialize: UnserializeFunction = (data, key) => {
     const initialState = getInitialState();
     const parsed = JSON.parse(data);
 
-    // We need to inject non-persisted values from initial state into the rehydrated state. These values always are
-    // required to be in the state, but won't be in the persisted data. Build an object that consists of only these
-    // values, then merge it with the rehydrated state.
-    const nonPersistedSubsetOfState = pick(initialState, persistConfig.persistDenylist ?? []);
-    const stateToMigrate = merge(deepClone(parsed), nonPersistedSubsetOfState);
-
-    // Run migrations to bring old state up to date with the current version.
-    const migrated = persistConfig.migrate(stateToMigrate);
+    // strip out old keys
+    const stripped = pick(deepClone(parsed), keys(initialState));
+    /*
+     * Merge in initial state as default values, covering any missing keys. You might be tempted to use _.defaultsDeep,
+     * but that merges arrays by index and partial objects by key. Using an identity function as the customizer results
+     * in behaviour like defaultsDeep, but doesn't overwrite any values that are not undefined in the migrated state.
+     */
+    const unPersistDenylisted = mergeWith(stripped, initialState, (objVal) => objVal);
+    // run (additive) migrations
+    const migrated = persistConfig.migrate(unPersistDenylisted);
 
     log.debug(
       {

invokeai/frontend/web/src/common/components/Picker/Picker.tsx

@@ -81,7 +81,7 @@ export type Group<T extends object> = {
   /**
    * A unique key used for type-checking the group. Use the `buildGroup` function to create a group, which will set this key.
    */
-  [uniqueGroupKey]: true;
+  [uniqueGroupKey]: true
 };
 
 type OptionOrGroup<T extends object> = T | Group<T>;

invokeai/frontend/web/src/common/components/SessionMenuItems.tsx

@@ -1,7 +1,7 @@
 import { MenuItem } from '@invoke-ai/ui-library';
 import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
-import { allEntitiesDeleted, inpaintMaskAdded } from 'features/controlLayers/store/canvasSlice';
-import { $canvasManager } from 'features/controlLayers/store/ephemeral';
+import { useCanvasManagerSafe } from 'features/controlLayers/hooks/useCanvasManager';
+import { allEntitiesDeleted, inpaintMaskAdded } from 'features/controlLayers/store/canvasInstanceSlice';
 import { paramsReset } from 'features/controlLayers/store/paramsSlice';
 import { selectActiveTab } from 'features/ui/store/uiSelectors';
 import { memo, useCallback } from 'react';
@@ -13,11 +13,12 @@ export const SessionMenuItems = memo(() => {
   const dispatch = useAppDispatch();
   const tab = useAppSelector(selectActiveTab);
 
+  const canvasManager = useCanvasManagerSafe();
   const resetCanvasLayers = useCallback(() => {
     dispatch(allEntitiesDeleted());
     dispatch(inpaintMaskAdded({ isSelected: true, isBookmarked: true }));
-    $canvasManager.get()?.stage.fitBboxToStage();
-  }, [dispatch]);
+    canvasManager?.stage.fitBboxToStage();
+  }, [dispatch, canvasManager]);
   const resetGenerationSettings = useCallback(() => {
     dispatch(paramsReset());
   }, [dispatch]);

invokeai/frontend/web/src/common/hooks/useImageUploadButton.tsx

@@ -31,14 +31,14 @@ import { useClientSideUpload } from './useClientSideUpload';
 type UseImageUploadButtonArgs =
   | {
       isDisabled?: boolean;
-      allowMultiple: false;
+      allowMultiple: false
       onUpload?: (imageDTO: ImageDTO) => void;
       onUploadStarted?: (files: File) => void;
       onError?: (error: unknown) => void;
     }
   | {
       isDisabled?: boolean;
-      allowMultiple: true;
+      allowMultiple: true
       onUpload?: (imageDTOs: ImageDTO[]) => void;
       onUploadStarted?: (files: File[]) => void;
       onError?: (error: unknown) => void;

invokeai/frontend/web/src/features/controlLayers/components/CanvasAlerts/CanvasAlertsBboxVisibility.tsx

@@ -1,6 +1,6 @@
 import { Alert, AlertIcon, AlertTitle } from '@invoke-ai/ui-library';
 import { useStore } from '@nanostores/react';
-import { useCanvasManager } from 'features/controlLayers/contexts/CanvasManagerProviderGate';
+import { useCanvasManager } from 'features/controlLayers/hooks/useCanvasManager';
 import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 

invokeai/frontend/web/src/features/controlLayers/components/CanvasAlerts/CanvasAlertsSelectedEntityStatus.tsx

@@ -33,13 +33,13 @@ type AlertData = {
 const buildSelectIsEnabled = (entityIdentifier: CanvasEntityIdentifier) =>
   createSelector(
     selectCanvasSlice,
-    (canvas) => selectEntityOrThrow(canvas, entityIdentifier, 'CanvasAlertsSelectedEntityStatusContent').isEnabled
+    (canvas) => canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'CanvasAlertsSelectedEntityStatusContent').isEnabled : true
   );
 
 const buildSelectIsLocked = (entityIdentifier: CanvasEntityIdentifier) =>
   createSelector(
     selectCanvasSlice,
-    (canvas) => selectEntityOrThrow(canvas, entityIdentifier, 'CanvasAlertsSelectedEntityStatusContent').isLocked
+    (canvas) => canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'CanvasAlertsSelectedEntityStatusContent').isLocked : false
   );
 
 const CanvasAlertsSelectedEntityStatusContent = memo(({ entityIdentifier, adapter }: ContentProps) => {

invokeai/frontend/web/src/features/controlLayers/components/CanvasBusySpinner.tsx

@@ -1,7 +1,7 @@
 import type { SpinnerProps } from '@invoke-ai/ui-library';
 import { Spinner } from '@invoke-ai/ui-library';
 import { useStore } from '@nanostores/react';
-import { useCanvasManager } from 'features/controlLayers/contexts/CanvasManagerProviderGate';
+import { useCanvasManager } from 'features/controlLayers/hooks/useCanvasManager';
 import { useAllEntityAdapters } from 'features/controlLayers/contexts/EntityAdapterContext';
 import { computed } from 'nanostores';
 import { memo, useMemo } from 'react';

invokeai/frontend/web/src/features/controlLayers/components/CanvasContextMenu/CanvasContextMenuItemsCropCanvasToBbox.tsx

@@ -1,5 +1,5 @@
 import { MenuItem } from '@invoke-ai/ui-library';
-import { useCanvasManager } from 'features/controlLayers/contexts/CanvasManagerProviderGate';
+import { useCanvasManager } from 'features/controlLayers/hooks/useCanvasManager';
 import { useCanvasIsBusy } from 'features/controlLayers/hooks/useCanvasIsBusy';
 import { memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList/CanvasEntityContainer.tsx

@@ -4,7 +4,7 @@ import { useAppDispatch } from 'app/store/storeHooks';
 import { useCanvasEntityListDnd } from 'features/controlLayers/components/CanvasEntityList/useCanvasEntityListDnd';
 import { useEntityIdentifierContext } from 'features/controlLayers/contexts/EntityIdentifierContext';
 import { useEntityIsSelected } from 'features/controlLayers/hooks/useEntityIsSelected';
-import { entitySelected } from 'features/controlLayers/store/canvasSlice';
+import { entitySelected } from 'features/controlLayers/store/canvasInstanceSlice';
 import { DndListDropIndicator } from 'features/dnd/DndListDropIndicator';
 import type { PropsWithChildren } from 'react';
 import { memo, useCallback, useRef } from 'react';

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList/CanvasEntityGroupList.tsx

@@ -13,7 +13,7 @@ import { CanvasEntityTypeIsHiddenToggle } from 'features/controlLayers/component
 import { RasterLayerExportPSDButton } from 'features/controlLayers/components/RasterLayer/RasterLayerExportPSDButton';
 import { useEntityTypeInformationalPopover } from 'features/controlLayers/hooks/useEntityTypeInformationalPopover';
 import { useEntityTypeTitle } from 'features/controlLayers/hooks/useEntityTypeTitle';
-import { entitiesReordered } from 'features/controlLayers/store/canvasSlice';
+import { entitiesReordered } from 'features/controlLayers/store/canvasInstanceSlice';
 import type { CanvasEntityIdentifier } from 'features/controlLayers/store/types';
 import { singleCanvasEntityDndSource } from 'features/dnd/dnd';
 import { triggerPostMoveFlash } from 'features/dnd/util';

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList/EntityListGlobalActionBarAddLayerMenu.tsx

@@ -6,7 +6,7 @@ import {
   useAddRasterLayer,
   useAddRegionalGuidance,
 } from 'features/controlLayers/hooks/addLayerHooks';
-import { useCanvasIsBusy } from 'features/controlLayers/hooks/useCanvasIsBusy';
+import { useCanvasIsBusySafe } from 'features/controlLayers/hooks/useCanvasIsBusy';
 import { useIsEntityTypeEnabled } from 'features/controlLayers/hooks/useIsEntityTypeEnabled';
 import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -14,7 +14,7 @@ import { PiPlusBold } from 'react-icons/pi';
 
 export const EntityListGlobalActionBarAddLayerMenu = memo(() => {
   const { t } = useTranslation();
-  const isBusy = useCanvasIsBusy();
+  const isBusy = useCanvasIsBusySafe();
   const addInpaintMask = useAddInpaintMask();
   const addRegionalGuidance = useAddRegionalGuidance();
   const addRegionalReferenceImage = useAddNewRegionalGuidanceWithARefImage();

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList/EntityListSelectedEntityActionBarDuplicateButton.tsx

@@ -1,7 +1,7 @@
 import { IconButton } from '@invoke-ai/ui-library';
 import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
-import { useCanvasIsBusy } from 'features/controlLayers/hooks/useCanvasIsBusy';
-import { entityDuplicated } from 'features/controlLayers/store/canvasSlice';
+import { useCanvasIsBusySafe } from 'features/controlLayers/hooks/useCanvasIsBusy';
+import { entityDuplicated } from 'features/controlLayers/store/canvasInstanceSlice';
 import { selectSelectedEntityIdentifier } from 'features/controlLayers/store/selectors';
 import { memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -10,7 +10,7 @@ import { PiCopyFill } from 'react-icons/pi';
 export const EntityListSelectedEntityActionBarDuplicateButton = memo(() => {
   const { t } = useTranslation();
   const dispatch = useAppDispatch();
-  const isBusy = useCanvasIsBusy();
+  const isBusy = useCanvasIsBusySafe();
   const selectedEntityIdentifier = useAppSelector(selectSelectedEntityIdentifier);
   const onClick = useCallback(() => {
     if (!selectedEntityIdentifier) {

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList/EntityListSelectedEntityActionBarFill.tsx

@@ -1,18 +1,9 @@
-import {
-  Box,
-  Flex,
-  Popover,
-  PopoverBody,
-  PopoverContent,
-  PopoverTrigger,
-  Portal,
-  Tooltip,
-} from '@invoke-ai/ui-library';
+import { Box, Flex, Popover, PopoverBody, PopoverContent, PopoverTrigger, Tooltip } from '@invoke-ai/ui-library';
 import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
 import RgbColorPicker from 'common/components/ColorPicker/RgbColorPicker';
 import { rgbColorToString } from 'common/util/colorCodeTransformers';
 import { MaskFillStyle } from 'features/controlLayers/components/common/MaskFillStyle';
-import { entityFillColorChanged, entityFillStyleChanged } from 'features/controlLayers/store/canvasSlice';
+import { entityFillColorChanged, entityFillStyleChanged } from 'features/controlLayers/store/canvasInstanceSlice';
 import { selectSelectedEntityFill, selectSelectedEntityIdentifier } from 'features/controlLayers/store/selectors';
 import { type FillStyle, isMaskEntityIdentifier, type RgbColor } from 'features/controlLayers/store/types';
 import { memo, useCallback } from 'react';
@@ -71,16 +62,14 @@ export const EntityListSelectedEntityActionBarFill = memo(() => {
           </Tooltip>
         </Flex>
       </PopoverTrigger>
-      <Portal>
-        <PopoverContent>
-          <PopoverBody minH={64}>
-            <Flex flexDir="column" gap={4}>
-              <RgbColorPicker color={fill.color} onChange={onChangeFillColor} withNumberInput withSwatches />
-              <MaskFillStyle style={fill.style} onChange={onChangeFillStyle} />
-            </Flex>
-          </PopoverBody>
-        </PopoverContent>
-      </Portal>
+      <PopoverContent>
+        <PopoverBody minH={64}>
+          <Flex flexDir="column" gap={4}>
+            <RgbColorPicker color={fill.color} onChange={onChangeFillColor} withNumberInput withSwatches />
+            <MaskFillStyle style={fill.style} onChange={onChangeFillStyle} />
+          </Flex>
+        </PopoverBody>
+      </PopoverContent>
     </Popover>
   );
 });

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList/EntityListSelectedEntityActionBarInvertMaskButton.tsx

@@ -1,6 +1,6 @@
 import { IconButton } from '@invoke-ai/ui-library';
 import { useAppSelector } from 'app/store/storeHooks';
-import { useCanvasIsBusy } from 'features/controlLayers/hooks/useCanvasIsBusy';
+import { useCanvasIsBusySafe } from 'features/controlLayers/hooks/useCanvasIsBusy';
 import { useInvertMask } from 'features/controlLayers/hooks/useInvertMask';
 import { selectSelectedEntityIdentifier } from 'features/controlLayers/store/selectors';
 import { isInpaintMaskEntityIdentifier } from 'features/controlLayers/store/types';
@@ -11,7 +11,7 @@ import { PiSelectionInverseBold } from 'react-icons/pi';
 export const EntityListSelectedEntityActionBarInvertMaskButton = memo(() => {
   const { t } = useTranslation();
   const selectedEntityIdentifier = useAppSelector(selectSelectedEntityIdentifier);
-  const isBusy = useCanvasIsBusy();
+  const isBusy = useCanvasIsBusySafe();
   const invertMask = useInvertMask();
 
   if (!selectedEntityIdentifier) {

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList/EntityListSelectedEntityActionBarOpacity.tsx

@@ -12,13 +12,12 @@ import {
   PopoverBody,
   PopoverContent,
   PopoverTrigger,
-  Portal,
 } from '@invoke-ai/ui-library';
 import { createSelector } from '@reduxjs/toolkit';
 import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
 import { clamp, round } from 'es-toolkit/compat';
 import { snapToNearest } from 'features/controlLayers/konva/util';
-import { entityOpacityChanged } from 'features/controlLayers/store/canvasSlice';
+import { entityOpacityChanged } from 'features/controlLayers/store/canvasInstanceSlice';
 import {
   selectCanvasSlice,
   selectEntity,
@@ -62,6 +61,9 @@ const sliderDefaultValue = mapRawValueToSliderValue(1);
 const snapCandidates = marks.slice(1, marks.length - 1);
 
 const selectOpacity = createSelector(selectCanvasSlice, (canvas) => {
+  if (!canvas) {
+    return 1; // fallback to 100% opacity
+  }
   const selectedEntityIdentifier = canvas.selectedEntityIdentifier;
   if (!selectedEntityIdentifier) {
     return 1; // fallback to 100% opacity
@@ -166,24 +168,22 @@ export const EntityListSelectedEntityActionBarOpacity = memo(() => {
           </NumberInput>
         </PopoverAnchor>
       </FormControl>
-      <Portal>
-        <PopoverContent w={200} pt={0} pb={2} px={4}>
-          <PopoverArrow />
-          <PopoverBody>
-            <CompositeSlider
-              min={0}
-              max={100}
-              value={localOpacity}
-              onChange={onChangeSlider}
-              defaultValue={sliderDefaultValue}
-              marks={marks}
-              formatValue={formatSliderValue}
-              alwaysShowMarks
-              isDisabled={selectedEntityIdentifier === null}
-            />
-          </PopoverBody>
-        </PopoverContent>
-      </Portal>
+      <PopoverContent w={200} pt={0} pb={2} px={4}>
+        <PopoverArrow />
+        <PopoverBody>
+          <CompositeSlider
+            min={0}
+            max={100}
+            value={localOpacity}
+            onChange={onChangeSlider}
+            defaultValue={sliderDefaultValue}
+            marks={marks}
+            formatValue={formatSliderValue}
+            alwaysShowMarks
+            isDisabled={selectedEntityIdentifier === null}
+          />
+        </PopoverBody>
+      </PopoverContent>
     </Popover>
   );
 });

invokeai/frontend/web/src/features/controlLayers/components/CanvasEntityList/EntityListSelectedEntityActionBarSaveToAssetsButton.tsx

@@ -1,7 +1,7 @@
 import { IconButton } from '@invoke-ai/ui-library';
 import { useAppSelector } from 'app/store/storeHooks';
 import { useEntityAdapterSafe } from 'features/controlLayers/contexts/EntityAdapterContext';
-import { useCanvasIsBusy } from 'features/controlLayers/hooks/useCanvasIsBusy';
+import { useCanvasIsBusySafe } from 'features/controlLayers/hooks/useCanvasIsBusy';
 import { useSaveLayerToAssets } from 'features/controlLayers/hooks/useSaveLayerToAssets';
 import { selectSelectedEntityIdentifier } from 'features/controlLayers/store/selectors';
 import { isSaveableEntityIdentifier } from 'features/controlLayers/store/types';
@@ -11,7 +11,7 @@ import { PiFloppyDiskBold } from 'react-icons/pi';
 
 export const EntityListSelectedEntityActionBarSaveToAssetsButton = memo(() => {
   const { t } = useTranslation();
-  const isBusy = useCanvasIsBusy();
+  const isBusy = useCanvasIsBusySafe();
   const selectedEntityIdentifier = useAppSelector(selectSelectedEntityIdentifier);
   const adapter = useEntityAdapterSafe(selectedEntityIdentifier);
   const saveLayerToAssets = useSaveLayerToAssets();

invokeai/frontend/web/src/features/controlLayers/components/CanvasLayersPanelContent.tsx

@@ -3,7 +3,7 @@ import { useAppSelector } from 'app/store/storeHooks';
 import { CanvasAddEntityButtons } from 'features/controlLayers/components/CanvasAddEntityButtons';
 import { CanvasEntityList } from 'features/controlLayers/components/CanvasEntityList/CanvasEntityList';
 import { EntityListSelectedEntityActionBar } from 'features/controlLayers/components/CanvasEntityList/EntityListSelectedEntityActionBar';
-import { CanvasManagerProviderGate } from 'features/controlLayers/contexts/CanvasManagerProviderGate';
+import { ActiveCanvasProvider } from 'features/controlLayers/contexts/ActiveCanvasProvider';
 import { selectHasEntities } from 'features/controlLayers/store/selectors';
 import { memo } from 'react';
 
@@ -13,7 +13,7 @@ export const CanvasLayersPanel = memo(() => {
   const hasEntities = useAppSelector(selectHasEntities);
 
   return (
-    <CanvasManagerProviderGate>
+    <ActiveCanvasProvider>
       <Flex flexDir="column" gap={2} w="full" h="full">
         <EntityListSelectedEntityActionBar />
         <Divider py={0} />
@@ -22,7 +22,7 @@ export const CanvasLayersPanel = memo(() => {
         {!hasEntities && <CanvasAddEntityButtons />}
         {hasEntities && <CanvasEntityList />}
       </Flex>
-    </CanvasManagerProviderGate>
+    </ActiveCanvasProvider>
   );
 });
 

invokeai/frontend/web/src/features/controlLayers/components/CanvasPasteModal.tsx

@@ -12,7 +12,7 @@ import {
 import { useStore } from '@nanostores/react';
 import { useAppSelector, useAppStore } from 'app/store/storeHooks';
 import { useAssertSingleton } from 'common/hooks/useAssertSingleton';
-import { useCanvasManager } from 'features/controlLayers/contexts/CanvasManagerProviderGate';
+import { useCanvasManagerSafe } from 'features/controlLayers/hooks/useCanvasManager';
 import { selectAutoAddBoardId } from 'features/gallery/store/gallerySelectors';
 import { createNewCanvasEntityFromImage } from 'features/imageActions/actions';
 import { toast } from 'features/toast/toast';
@@ -31,13 +31,20 @@ export const CanvasPasteModal = memo(() => {
   const { dispatch, getState } = useAppStore();
   const { t } = useTranslation();
   const imageToPaste = useStore($imageFile);
-  const canvasManager = useCanvasManager();
+  const canvasManager = useCanvasManagerSafe();
   const autoAddBoardId = useAppSelector(selectAutoAddBoardId);
   const [uploadImage, { isLoading }] = useUploadImageMutation({ fixedCacheKey: 'canvasPasteModal' });
 
   const getPosition = useCallback(
     (destination: 'canvas' | 'bbox') => {
-      const { x, y } = canvasManager.stateApi.getBbox().rect;
+      if (!canvasManager) {
+        return { x: 0, y: 0 };
+      }
+      const bbox = canvasManager.stateApi.getBbox();
+      if (!bbox) {
+        return { x: 0, y: 0 };
+      }
+      const { x, y } = bbox.rect;
       if (destination === 'bbox') {
         return { x, y };
       }
@@ -50,7 +57,7 @@ export const CanvasPasteModal = memo(() => {
         return { x, y };
       }
     },
-    [canvasManager.compositor, canvasManager.stateApi]
+    [canvasManager]
   );
 
   const handlePaste = useCallback(

invokeai/frontend/web/src/features/controlLayers/components/ControlLayer/ControlLayerBadges.tsx

@@ -11,7 +11,7 @@ import { useTranslation } from 'react-i18next';
 const buildSelectWithTransparencyEffect = (entityIdentifier: CanvasEntityIdentifier<'control_layer'>) =>
   createSelector(
     selectCanvasSlice,
-    (canvas) => selectEntityOrThrow(canvas, entityIdentifier, 'ControlLayerBadgesContent').withTransparencyEffect
+    (canvas) => canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'ControlLayerBadgesContent').withTransparencyEffect : false
   );
 
 const ControlLayerBadgesContent = memo(() => {

invokeai/frontend/web/src/features/controlLayers/components/ControlLayer/ControlLayerControlAdapter.tsx

@@ -16,7 +16,7 @@ import {
   controlLayerControlModeChanged,
   controlLayerModelChanged,
   controlLayerWeightChanged,
-} from 'features/controlLayers/store/canvasSlice';
+} from 'features/controlLayers/store/canvasInstanceSlice';
 import { getFilterForModel } from 'features/controlLayers/store/filters';
 import { selectIsFLUX } from 'features/controlLayers/store/paramsSlice';
 import { selectCanvasSlice, selectEntityOrThrow } from 'features/controlLayers/store/selectors';
@@ -34,8 +34,8 @@ import type {
 
 const buildSelectControlAdapter = (entityIdentifier: CanvasEntityIdentifier<'control_layer'>) =>
   createSelector(selectCanvasSlice, (canvas) => {
-    const layer = selectEntityOrThrow(canvas, entityIdentifier, 'ControlLayerControlAdapter');
-    return layer.controlAdapter;
+    const layer = canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'ControlLayerControlAdapter') : null;
+    return layer ? layer.controlAdapter : null;
   });
 
 export const ControlLayerControlAdapter = memo(() => {
@@ -125,6 +125,10 @@ export const ControlLayerControlAdapter = memo(() => {
   );
   const uploadApi = useImageUploadButton(uploadOptions);
 
+  if (!controlAdapter) {
+    return null;
+  }
+
   return (
     <Flex flexDir="column" gap={3} position="relative" w="full">
       <Flex w="full" gap={2}>
@@ -162,7 +166,7 @@ export const ControlLayerControlAdapter = memo(() => {
         <input {...uploadApi.getUploadInputProps()} />
       </Flex>
       <Weight weight={controlAdapter.weight} onChange={onChangeWeight} />
-      {controlAdapter.type !== 'control_lora' && (
+      {(controlAdapter.type === 'controlnet' || controlAdapter.type === 't2i_adapter') && (
         <BeginEndStepPct beginEndStepPct={controlAdapter.beginEndStepPct} onChange={onChangeBeginEndStepPct} />
       )}
       {controlAdapter.type === 'controlnet' && !isFLUX && (

invokeai/frontend/web/src/features/controlLayers/components/ControlLayer/ControlLayerEntityList.tsx

@@ -8,7 +8,7 @@ import { getEntityIdentifier } from 'features/controlLayers/store/types';
 import { memo } from 'react';
 
 const selectEntityIdentifiers = createMemoizedSelector(selectCanvasSlice, (canvas) => {
-  return canvas.controlLayers.entities.map(getEntityIdentifier).toReversed();
+  return canvas ? canvas.controlLayers.entities.map(getEntityIdentifier).toReversed() : [];
 });
 
 const selectIsSelected = createSelector(selectSelectedEntityIdentifier, (selectedEntityIdentifier) => {

invokeai/frontend/web/src/features/controlLayers/components/ControlLayer/ControlLayerMenuItemsConvertToSubMenu.tsx

@@ -8,7 +8,7 @@ import {
   controlLayerConvertedToInpaintMask,
   controlLayerConvertedToRasterLayer,
   controlLayerConvertedToRegionalGuidance,
-} from 'features/controlLayers/store/canvasSlice';
+} from 'features/controlLayers/store/canvasInstanceSlice';
 import { memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
 import { PiSwapBold } from 'react-icons/pi';

invokeai/frontend/web/src/features/controlLayers/components/ControlLayer/ControlLayerMenuItemsCopyToSubMenu.tsx

@@ -8,7 +8,7 @@ import {
   controlLayerConvertedToInpaintMask,
   controlLayerConvertedToRasterLayer,
   controlLayerConvertedToRegionalGuidance,
-} from 'features/controlLayers/store/canvasSlice';
+} from 'features/controlLayers/store/canvasInstanceSlice';
 import { memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
 import { PiCopyBold } from 'react-icons/pi';

invokeai/frontend/web/src/features/controlLayers/components/ControlLayer/ControlLayerMenuItemsTransparencyEffect.tsx

@@ -3,7 +3,7 @@ import { createSelector } from '@reduxjs/toolkit';
 import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
 import { useEntityIdentifierContext } from 'features/controlLayers/contexts/EntityIdentifierContext';
 import { useEntityIsLocked } from 'features/controlLayers/hooks/useEntityIsLocked';
-import { controlLayerWithTransparencyEffectToggled } from 'features/controlLayers/store/canvasSlice';
+import { controlLayerWithTransparencyEffectToggled } from 'features/controlLayers/store/canvasInstanceSlice';
 import { selectCanvasSlice, selectEntityOrThrow } from 'features/controlLayers/store/selectors';
 import type { CanvasEntityIdentifier } from 'features/controlLayers/store/types';
 import { memo, useCallback, useMemo } from 'react';
@@ -14,7 +14,7 @@ const buildSelectWithTransparencyEffect = (entityIdentifier: CanvasEntityIdentif
   createSelector(
     selectCanvasSlice,
     (canvas) =>
-      selectEntityOrThrow(canvas, entityIdentifier, 'ControlLayerMenuItemsTransparencyEffect').withTransparencyEffect
+      canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'ControlLayerMenuItemsTransparencyEffect').withTransparencyEffect : false
   );
 
 export const ControlLayerMenuItemsTransparencyEffect = memo(() => {

invokeai/frontend/web/src/features/controlLayers/components/Filters/Filter.tsx

@@ -18,7 +18,7 @@ import { CanvasAutoProcessSwitch } from 'features/controlLayers/components/Canva
 import { CanvasOperationIsolatedLayerPreviewSwitch } from 'features/controlLayers/components/CanvasOperationIsolatedLayerPreviewSwitch';
 import { FilterSettings } from 'features/controlLayers/components/Filters/FilterSettings';
 import { FilterTypeSelect } from 'features/controlLayers/components/Filters/FilterTypeSelect';
-import { useCanvasManager } from 'features/controlLayers/contexts/CanvasManagerProviderGate';
+import { useCanvasManager } from 'features/controlLayers/hooks/useCanvasManager';
 import type { CanvasEntityAdapterControlLayer } from 'features/controlLayers/konva/CanvasEntity/CanvasEntityAdapterControlLayer';
 import type { CanvasEntityAdapterRasterLayer } from 'features/controlLayers/konva/CanvasEntity/CanvasEntityAdapterRasterLayer';
 import { selectAutoProcess } from 'features/controlLayers/store/canvasSettingsSlice';

invokeai/frontend/web/src/features/controlLayers/components/HUD/CanvasHUDItemBbox.tsx

@@ -5,7 +5,7 @@ import { selectBbox } from 'features/controlLayers/store/selectors';
 import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
-const selectBboxRect = createSelector(selectBbox, (bbox) => bbox.rect);
+const selectBboxRect = createSelector(selectBbox, (bbox) => bbox?.rect || { width: 0, height: 0 });
 
 export const CanvasHUDItemBbox = memo(() => {
   const { t } = useTranslation();

invokeai/frontend/web/src/features/controlLayers/components/HUD/CanvasHUDItemScaledBbox.tsx

@@ -9,7 +9,7 @@ export const CanvasHUDItemScaledBbox = memo(() => {
   const scaleMethod = useAppSelector(selectScaleMethod);
   const scaledSize = useAppSelector(selectScaledSize);
 
-  if (scaleMethod === 'none') {
+  if (scaleMethod === 'none' || !scaledSize) {
     return null;
   }
 

invokeai/frontend/web/src/features/controlLayers/components/InpaintMask/InpaintMaskDenoiseLimitSlider.tsx

@@ -6,7 +6,7 @@ import { useEntityIdentifierContext } from 'features/controlLayers/contexts/Enti
 import {
   inpaintMaskDenoiseLimitChanged,
   inpaintMaskDenoiseLimitDeleted,
-} from 'features/controlLayers/store/canvasSlice';
+} from 'features/controlLayers/store/canvasInstanceSlice';
 import { selectCanvasSlice, selectEntityOrThrow } from 'features/controlLayers/store/selectors';
 import { memo, useCallback, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -20,7 +20,7 @@ export const InpaintMaskDenoiseLimitSlider = memo(() => {
     () =>
       createSelector(
         selectCanvasSlice,
-        (canvas) => selectEntityOrThrow(canvas, entityIdentifier, 'InpaintMaskDenoiseLimitSlider').denoiseLimit
+        (canvas) => canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'InpaintMaskDenoiseLimitSlider').denoiseLimit : undefined
       ),
     [entityIdentifier]
   );

invokeai/frontend/web/src/features/controlLayers/components/InpaintMask/InpaintMaskList.tsx

@@ -8,7 +8,7 @@ import { getEntityIdentifier } from 'features/controlLayers/store/types';
 import { memo } from 'react';
 
 const selectEntityIdentifiers = createMemoizedSelector(selectCanvasSlice, (canvas) => {
-  return canvas.inpaintMasks.entities.map(getEntityIdentifier).toReversed();
+  return canvas ? canvas.inpaintMasks.entities.map(getEntityIdentifier).toReversed() : [];
 });
 
 const selectIsSelected = createSelector(selectSelectedEntityIdentifier, (selectedEntityIdentifier) => {

invokeai/frontend/web/src/features/controlLayers/components/InpaintMask/InpaintMaskMenuItemsConvertToSubMenu.tsx

@@ -4,7 +4,7 @@ import { SubMenuButtonContent, useSubMenu } from 'common/hooks/useSubMenu';
 import { useEntityIdentifierContext } from 'features/controlLayers/contexts/EntityIdentifierContext';
 import { useCanvasIsBusy } from 'features/controlLayers/hooks/useCanvasIsBusy';
 import { useEntityIsLocked } from 'features/controlLayers/hooks/useEntityIsLocked';
-import { inpaintMaskConvertedToRegionalGuidance } from 'features/controlLayers/store/canvasSlice';
+import { inpaintMaskConvertedToRegionalGuidance } from 'features/controlLayers/store/canvasInstanceSlice';
 import { memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
 import { PiSwapBold } from 'react-icons/pi';

invokeai/frontend/web/src/features/controlLayers/components/InpaintMask/InpaintMaskMenuItemsCopyToSubMenu.tsx

@@ -4,7 +4,7 @@ import { SubMenuButtonContent, useSubMenu } from 'common/hooks/useSubMenu';
 import { CanvasEntityMenuItemsCopyToClipboard } from 'features/controlLayers/components/common/CanvasEntityMenuItemsCopyToClipboard';
 import { useEntityIdentifierContext } from 'features/controlLayers/contexts/EntityIdentifierContext';
 import { useCanvasIsBusy } from 'features/controlLayers/hooks/useCanvasIsBusy';
-import { inpaintMaskConvertedToRegionalGuidance } from 'features/controlLayers/store/canvasSlice';
+import { inpaintMaskConvertedToRegionalGuidance } from 'features/controlLayers/store/canvasInstanceSlice';
 import { memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
 import { PiCopyBold } from 'react-icons/pi';

invokeai/frontend/web/src/features/controlLayers/components/InpaintMask/InpaintMaskNoiseSlider.tsx

@@ -3,7 +3,7 @@ import { createSelector } from '@reduxjs/toolkit';
 import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
 import { InpaintMaskDeleteModifierButton } from 'features/controlLayers/components/InpaintMask/InpaintMaskDeleteModifierButton';
 import { useEntityIdentifierContext } from 'features/controlLayers/contexts/EntityIdentifierContext';
-import { inpaintMaskNoiseChanged, inpaintMaskNoiseDeleted } from 'features/controlLayers/store/canvasSlice';
+import { inpaintMaskNoiseChanged, inpaintMaskNoiseDeleted } from 'features/controlLayers/store/canvasInstanceSlice';
 import { selectCanvasSlice, selectEntityOrThrow } from 'features/controlLayers/store/selectors';
 import { memo, useCallback, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -17,7 +17,7 @@ export const InpaintMaskNoiseSlider = memo(() => {
     () =>
       createSelector(
         selectCanvasSlice,
-        (canvas) => selectEntityOrThrow(canvas, entityIdentifier, 'InpaintMaskNoiseSlider').noiseLevel
+        (canvas) => canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'InpaintMaskNoiseSlider').noiseLevel : undefined
       ),
     [entityIdentifier]
   );

invokeai/frontend/web/src/features/controlLayers/components/InpaintMask/InpaintMaskSettings.tsx

@@ -10,14 +10,14 @@ import { memo, useMemo } from 'react';
 
 const buildSelectHasDenoiseLimit = (entityIdentifier: CanvasEntityIdentifier<'inpaint_mask'>) =>
   createSelector(selectCanvasSlice, (canvas) => {
-    const entity = selectEntityOrThrow(canvas, entityIdentifier, 'InpaintMaskSettings');
-    return entity.denoiseLimit !== undefined;
+    const entity = canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'InpaintMaskSettings') : null;
+    return entity ? entity.denoiseLimit !== undefined : false
   });
 
 const buildSelectHasNoiseLevel = (entityIdentifier: CanvasEntityIdentifier<'inpaint_mask'>) =>
   createSelector(selectCanvasSlice, (canvas) => {
-    const entity = selectEntityOrThrow(canvas, entityIdentifier, 'InpaintMaskSettings');
-    return entity.noiseLevel !== undefined;
+    const entity = canvas ? selectEntityOrThrow(canvas, entityIdentifier, 'InpaintMaskSettings') : null;
+    return entity ? entity.noiseLevel !== undefined : false
   });
 
 export const InpaintMaskSettings = memo(() => {

invokeai/frontend/web/src/features/controlLayers/components/InvokeCanvasComponent.tsx

@@ -3,7 +3,9 @@ import { useInvokeCanvas } from 'features/controlLayers/hooks/useInvokeCanvas';
 import { memo } from 'react';
 
 export const InvokeCanvasComponent = memo(() => {
+  console.log('InvokeCanvasComponent rendering');
   const ref = useInvokeCanvas();
+  console.log('InvokeCanvasComponent - ref obtained:', !!ref);
 
   return (
     <Box

invokeai/frontend/web/src/features/controlLayers/components/RasterLayer/RasterLayer.tsx

@@ -4,11 +4,10 @@ import { CanvasEntityHeader } from 'features/controlLayers/components/common/Can
 import { CanvasEntityHeaderCommonActions } from 'features/controlLayers/components/common/CanvasEntityHeaderCommonActions';
 import { CanvasEntityPreviewImage } from 'features/controlLayers/components/common/CanvasEntityPreviewImage';
 import { CanvasEntityEditableTitle } from 'features/controlLayers/components/common/CanvasEntityTitleEdit';
-import { RasterLayerAdjustmentsPanel } from 'features/controlLayers/components/RasterLayer/RasterLayerAdjustmentsPanel';
 import { CanvasEntityStateGate } from 'features/controlLayers/contexts/CanvasEntityStateGate';
 import { RasterLayerAdapterGate } from 'features/controlLayers/contexts/EntityAdapterContext';
 import { EntityIdentifierContext } from 'features/controlLayers/contexts/EntityIdentifierContext';
-import { useCanvasIsBusy } from 'features/controlLayers/hooks/useCanvasIsBusy';
+import { useCanvasIsBusySafe } from 'features/controlLayers/hooks/useCanvasIsBusy';
 import type { CanvasEntityIdentifier } from 'features/controlLayers/store/types';
 import type { ReplaceCanvasEntityObjectsWithImageDndTargetData } from 'features/dnd/dnd';
 import { replaceCanvasEntityObjectsWithImageDndTarget } from 'features/dnd/dnd';
@@ -22,7 +21,7 @@ type Props = {
 
 export const RasterLayer = memo(({ id }: Props) => {
   const { t } = useTranslation();
-  const isBusy = useCanvasIsBusy();
+  const isBusy = useCanvasIsBusySafe();
   const entityIdentifier = useMemo<CanvasEntityIdentifier<'raster_layer'>>(() => ({ id, type: 'raster_layer' }), [id]);
   const dndTargetData = useMemo<ReplaceCanvasEntityObjectsWithImageDndTargetData>(
     () => replaceCanvasEntityObjectsWithImageDndTarget.getData({ entityIdentifier }, entityIdentifier.id),
@@ -40,7 +39,6 @@ export const RasterLayer = memo(({ id }: Props) => {
               <Spacer />
               <CanvasEntityHeaderCommonActions />
             </CanvasEntityHeader>
-            <RasterLayerAdjustmentsPanel />
             <DndDropTarget
               dndTarget={replaceCanvasEntityObjectsWithImageDndTarget}
               dndTargetData={dndTargetData}

invokeai/frontend/web/src/features/controlLayers/components/RasterLayer/RasterLayerAdjustmentsPanel.tsx

@@ -1,167 +0,0 @@
-import { Button, ButtonGroup, Flex, IconButton, Switch, Text } from '@invoke-ai/ui-library';
-import { createSelector } from '@reduxjs/toolkit';
-import { useAppDispatch, useAppSelector } from 'app/store/storeHooks';
-import { RasterLayerCurvesAdjustmentsEditor } from 'features/controlLayers/components/RasterLayer/RasterLayerCurvesAdjustmentsEditor';
-import { RasterLayerSimpleAdjustmentsEditor } from 'features/controlLayers/components/RasterLayer/RasterLayerSimpleAdjustmentsEditor';
-import { useCanvasManager } from 'features/controlLayers/contexts/CanvasManagerProviderGate';
-import { useEntityIdentifierContext } from 'features/controlLayers/contexts/EntityIdentifierContext';
-import {
-  rasterLayerAdjustmentsCancel,
-  rasterLayerAdjustmentsCollapsedToggled,
-  rasterLayerAdjustmentsEnabledToggled,
-  rasterLayerAdjustmentsModeChanged,
-  rasterLayerAdjustmentsReset,
-  rasterLayerAdjustmentsSet,
-} from 'features/controlLayers/store/canvasSlice';
-import { selectCanvasSlice, selectEntity } from 'features/controlLayers/store/selectors';
-import React, { memo, useCallback, useMemo } from 'react';
-import { useTranslation } from 'react-i18next';
-import { PiArrowCounterClockwiseBold, PiCaretDownBold, PiCheckBold, PiTrashBold } from 'react-icons/pi';
-
-export const RasterLayerAdjustmentsPanel = memo(() => {
-  const { t } = useTranslation();
-  const dispatch = useAppDispatch();
-  const entityIdentifier = useEntityIdentifierContext<'raster_layer'>();
-  const canvasManager = useCanvasManager();
-
-  const selectHasAdjustments = useMemo(() => {
-    return createSelector(selectCanvasSlice, (canvas) => Boolean(selectEntity(canvas, entityIdentifier)?.adjustments));
-  }, [entityIdentifier]);
-
-  const hasAdjustments = useAppSelector(selectHasAdjustments);
-
-  const selectMode = useMemo(() => {
-    return createSelector(
-      selectCanvasSlice,
-      (canvas) => selectEntity(canvas, entityIdentifier)?.adjustments?.mode ?? 'simple'
-    );
-  }, [entityIdentifier]);
-  const mode = useAppSelector(selectMode);
-
-  const selectEnabled = useMemo(() => {
-    return createSelector(
-      selectCanvasSlice,
-      (canvas) => selectEntity(canvas, entityIdentifier)?.adjustments?.enabled ?? false
-    );
-  }, [entityIdentifier]);
-  const enabled = useAppSelector(selectEnabled);
-
-  const selectCollapsed = useMemo(() => {
-    return createSelector(
-      selectCanvasSlice,
-      (canvas) => selectEntity(canvas, entityIdentifier)?.adjustments?.collapsed ?? false
-    );
-  }, [entityIdentifier]);
-  const collapsed = useAppSelector(selectCollapsed);
-
-  const onToggleEnabled = useCallback(() => {
-    dispatch(rasterLayerAdjustmentsEnabledToggled({ entityIdentifier }));
-  }, [dispatch, entityIdentifier]);
-
-  const onReset = useCallback(() => {
-    // Reset values to defaults but keep adjustments present; preserve enabled/collapsed/mode
-    dispatch(rasterLayerAdjustmentsReset({ entityIdentifier }));
-  }, [dispatch, entityIdentifier]);
-
-  const onCancel = useCallback(() => {
-    // Clear out adjustments entirely
-    dispatch(rasterLayerAdjustmentsCancel({ entityIdentifier }));
-  }, [dispatch, entityIdentifier]);
-
-  const onToggleCollapsed = useCallback(() => {
-    dispatch(rasterLayerAdjustmentsCollapsedToggled({ entityIdentifier }));
-  }, [dispatch, entityIdentifier]);
-
-  const onClickModeSimple = useCallback(
-    () => dispatch(rasterLayerAdjustmentsModeChanged({ entityIdentifier, mode: 'simple' })),
-    [dispatch, entityIdentifier]
-  );
-
-  const onClickModeCurves = useCallback(
-    () => dispatch(rasterLayerAdjustmentsModeChanged({ entityIdentifier, mode: 'curves' })),
-    [dispatch, entityIdentifier]
-  );
-
-  const onFinish = useCallback(async () => {
-    // Bake current visual into layer pixels, then clear adjustments
-    const adapter = canvasManager.getAdapter(entityIdentifier);
-    if (!adapter || adapter.type !== 'raster_layer_adapter') {
-      return;
-    }
-    const rect = adapter.transformer.getRelativeRect();
-    try {
-      await adapter.renderer.rasterize({ rect, replaceObjects: true, attrs: { opacity: 1 } });
-      // Clear adjustments after baking
-      dispatch(rasterLayerAdjustmentsSet({ entityIdentifier, adjustments: null }));
-    } catch {
-      // no-op; leave state unchanged on failure
-    }
-  }, [canvasManager, entityIdentifier, dispatch]);
-
-  // Hide the panel entirely until adjustments are added via context menu
-  if (!hasAdjustments) {
-    return null;
-  }
-
-  return (
-    <>
-      <Flex px={2} pb={2} alignItems="center" gap={2}>
-        <IconButton
-          aria-label={collapsed ? t('controlLayers.adjustments.expand') : t('controlLayers.adjustments.collapse')}
-          size="sm"
-          variant="ghost"
-          onClick={onToggleCollapsed}
-          icon={
-            <PiCaretDownBold
-              style={{ transform: collapsed ? 'rotate(-90deg)' : 'rotate(0deg)', transition: 'transform 0.2s' }}
-            />
-          }
-        />
-        <Text fontWeight={600} flex={1}>
-          Adjustments
-        </Text>
-        <ButtonGroup size="sm" isAttached variant="outline">
-          <Button onClick={onClickModeSimple} colorScheme={mode === 'simple' ? 'invokeBlue' : undefined}>
-            {t('controlLayers.adjustments.simple')}
-          </Button>
-          <Button onClick={onClickModeCurves} colorScheme={mode === 'curves' ? 'invokeBlue' : undefined}>
-            {t('controlLayers.adjustments.curves')}
-          </Button>
-        </ButtonGroup>
-        <Switch isChecked={enabled} onChange={onToggleEnabled} />
-        <IconButton
-          aria-label={t('controlLayers.adjustments.cancel')}
-          size="md"
-          onClick={onCancel}
-          isDisabled={!hasAdjustments}
-          colorScheme="red"
-          icon={<PiTrashBold />}
-          variant="ghost"
-        />
-        <IconButton
-          aria-label={t('controlLayers.adjustments.reset')}
-          size="md"
-          onClick={onReset}
-          isDisabled={!hasAdjustments}
-          icon={<PiArrowCounterClockwiseBold />}
-          variant="ghost"
-        />
-        <IconButton
-          aria-label={t('controlLayers.adjustments.finish')}
-          size="md"
-          onClick={onFinish}
-          isDisabled={!hasAdjustments}
-          colorScheme="green"
-          icon={<PiCheckBold />}
-          variant="ghost"
-        />
-      </Flex>
-
-      {!collapsed && mode === 'simple' && <RasterLayerSimpleAdjustmentsEditor />}
-
-      {!collapsed && mode === 'curves' && <RasterLayerCurvesAdjustmentsEditor />}
-    </>
-  );
-});
-
-RasterLayerAdjustmentsPanel.displayName = 'RasterLayerAdjustmentsPanel';