pixelweaver 0.1.0

package/src/lib/layers/layer-commands.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { commandRegistry } from '../core/registries.svelte.js';
+import { dispatch, undoLast, _resetForTesting as resetDispatcher } from '../core/dispatcher.js';
+import { layerCommandsPlugin } from './layer-commands.js';
+import * as tree from './layer-tree.svelte.js';
+import type { Command } from '../core/commands.js';
+import type { CommandType, ParamsOf } from '../core/command-params.js';
+import { createPluginAPI } from '../core/plugin-api.js';
+import { notificationState } from '../core/notification-state.svelte.js';
+
+// --- Helpers ---
+
+// Typed overload: validates params when type is a known command literal
+function makeCommand<T extends CommandType>(type: T, params: ParamsOf<T>): Command;
+// String fallback: for dynamic/unknown command types in tests
+function makeCommand(type: string, params?: Record<string, unknown>): Command;
+function makeCommand(type: string, params: Record<string, unknown> = {}): Command {
+  return {
+    type,
+    plugin: 'builtin/layers',
+    version: '1.0.0',
+    params,
+    timestamp: Date.now(),
+    id: crypto.randomUUID(),
+  };
+}
+
+// --- Setup ---
+
+beforeEach(() => {
+  tree._resetForTesting();
+  resetDispatcher();
+  notificationState.dismissAll();
+  // Register the layer commands plugin
+  const api = createPluginAPI('builtin/layers');
+  layerCommandsPlugin.register(api);
+});
+
+// --- Tests ---
+
+describe('add_layer command', () => {
+  it('should add a layer to the tree', () => {
+    dispatch(makeCommand('add_layer', { name: 'Test Layer' }));
+    expect(tree.getLayers()).toHaveLength(1);
+    expect(tree.getLayers()[0]?.name).toBe('Test Layer');
+  });
+
+  it('should undo by removing the added layer', () => {
+    dispatch(makeCommand('add_layer', { name: 'Test Layer' }));
+    expect(tree.getLayers()).toHaveLength(1);
+    undoLast();
+    expect(tree.getLayers()).toHaveLength(0);
+  });
+
+  it('should describe the action', () => {
+    const def = commandRegistry.get('add_layer');
+    if (!def) throw new Error(`command 'add_layer' not registered`);
+    const desc = def.describe({ name: 'Background' });
+    expect(desc).toBe('Added layer "Background"');
+  });
+});
+
+describe('remove_layer command', () => {
+  it('should remove a layer from the tree', () => {
+    const layer = tree.addLayer('Victim');
+    dispatch(makeCommand('remove_layer', { id: layer.id }));
+    expect(tree.getLayers()).toHaveLength(0);
+  });
+
+  it('should undo by restoring the removed layer at its original position', () => {
+    const l1 = tree.addLayer('First');
+    const l2 = tree.addLayer('Second');
+    tree.addLayer('Third');
+    tree.setActiveLayer(l1.id);
+
+    dispatch(makeCommand('remove_layer', { id: l2.id }));
+    expect(tree.getLayers()).toHaveLength(2);
+
+    undoLast();
+    expect(tree.getLayers()).toHaveLength(3);
+    expect(tree.getLayers()[1]?.id).toBe(l2.id);
+    expect(tree.getLayers()[1]?.name).toBe('Second');
+  });
+
+  it('should describe the action', () => {
+    const layer = tree.addLayer('Background');
+    const cmd = makeCommand('remove_layer', { id: layer.id });
+    dispatch(cmd);
+    const def = commandRegistry.get('remove_layer');
+    if (!def) throw new Error(`command 'remove_layer' not registered`);
+    const desc = def.describe(cmd.params);
+    expect(desc).toContain('Background');
+  });
+
+  it('should fall back to root with a notification when the parent group is gone on undo', () => {
+    // Set up: a pixel layer inside a group, then delete the inner layer.
+    // Before undoing, remove the group from the tree directly (without going
+    // through the dispatcher) so that the layer-removal undo entry remains
+    // at the top of the stack but its snapshotted parentId now points at a
+    // group that no longer exists -- the orphaned-parent scenario.
+    const inner = tree.addLayer('Inner');
+    const group = tree.groupLayers([inner.id], 'Doomed Group');
+    expect(tree.getLayers()).toHaveLength(1);
+    expect(tree.getLayers()[0]?.id).toBe(group.id);
+
+    // Delete the inner layer through the dispatcher (snapshots parentId=group.id)
+    dispatch(makeCommand('remove_layer', { id: inner.id }));
+    expect(tree.getLayer(inner.id)).toBeUndefined();
+
+    // Directly remove the parent group, bypassing the dispatcher so the
+    // layer-removal entry stays at the top of the undo stack.
+    tree.removeLayer(group.id);
+    expect(tree.getLayer(group.id)).toBeUndefined();
+    expect(tree.getLayers()).toHaveLength(0);
+
+    // Undoing the layer removal should land it at the root, not silently drop it.
+    notificationState.dismissAll();
+    undoLast();
+
+    expect(tree.getLayer(inner.id)).toBeDefined();
+    expect(tree.getLayers().some((l) => l.id === inner.id)).toBe(true);
+
+    // And a warning notification should have been pushed.
+    const warning = notificationState.notifications.find(
+      (n) => n.id === `restore-layer-orphan-${inner.id}`,
+    );
+    expect(warning).toBeDefined();
+    expect(warning?.type).toBe('warning');
+    expect(warning?.message).toContain('Parent group for restored layer no longer exists');
+  });
+});
+
+describe('rename_layer command', () => {
+  it('should rename the layer', () => {
+    const layer = tree.addLayer('Old');
+    dispatch(makeCommand('rename_layer', { id: layer.id, name: 'New' }));
+    expect(layer.name).toBe('New');
+  });
+
+  it('should undo to restore old name', () => {
+    const layer = tree.addLayer('Old');
+    dispatch(makeCommand('rename_layer', { id: layer.id, name: 'New' }));
+    undoLast();
+    expect(layer.name).toBe('Old');
+  });
+
+  it('should describe the action', () => {
+    const def = commandRegistry.get('rename_layer');
+    if (!def) throw new Error(`command 'rename_layer' not registered`);
+    const desc = def.describe({ name: 'Hair' });
+    expect(desc).toBe('Renamed layer to "Hair"');
+  });
+});
+
+describe('move_layer command', () => {
+  it('should move a layer and undo to restore original position', () => {
+    const l1 = tree.addLayer('First');
+    tree.addLayer('Second');
+    tree.setActiveLayer(l1.id);
+
+    // Move l1 to index 1 (above l2)
+    dispatch(makeCommand('move_layer', { id: l1.id, newParentId: null, newIndex: 1 }));
+    expect(tree.getLayers()[1]?.id).toBe(l1.id);
+
+    undoLast();
+    expect(tree.getLayers()[0]?.id).toBe(l1.id);
+  });
+});
+
+describe('set_layer_visibility command', () => {
+  it('should toggle visibility and undo', () => {
+    const layer = tree.addLayer('Layer');
+    dispatch(makeCommand('set_layer_visibility', { id: layer.id, visible: false }));
+    expect(layer.visible).toBe(false);
+
+    undoLast();
+    expect(layer.visible).toBe(true);
+  });
+});
+
+describe('set_layer_opacity command', () => {
+  it('should change opacity and undo', () => {
+    const layer = tree.addLayer('Layer');
+    dispatch(makeCommand('set_layer_opacity', { id: layer.id, opacity: 50 }));
+    expect(layer.opacity).toBe(50);
+
+    undoLast();
+    expect(layer.opacity).toBe(100);
+  });
+});
+
+describe('set_active_layer command', () => {
+  it('should change active layer and undo', () => {
+    const l1 = tree.addLayer('A');
+    const l2 = tree.addLayer('B');
+    // l2 is active after addLayer
+
+    dispatch(makeCommand('set_active_layer', { id: l1.id }));
+    expect(tree.getActiveLayerId()).toBe(l1.id);
+
+    undoLast();
+    expect(tree.getActiveLayerId()).toBe(l2.id);
+  });
+});
+
+describe('group_layers command', () => {
+  it('should group and undo', () => {
+    const l1 = tree.addLayer('A');
+    const l2 = tree.addLayer('B');
+
+    dispatch(makeCommand('group_layers', { ids: [l1.id, l2.id], groupName: 'Group' }));
+    expect(tree.getLayers()).toHaveLength(1);
+    expect(tree.getLayers()[0]?.type).toBe('group');
+
+    undoLast();
+    expect(tree.getLayers()).toHaveLength(2);
+    expect(tree.getLayers()[0]?.id).toBe(l1.id);
+    expect(tree.getLayers()[1]?.id).toBe(l2.id);
+  });
+});
+
+describe('ungroup_layer command', () => {
+  it('should ungroup and undo', () => {
+    const l1 = tree.addLayer('A');
+    const l2 = tree.addLayer('B');
+    const group = tree.groupLayers([l1.id, l2.id], 'Group');
+
+    dispatch(makeCommand('ungroup_layer', { id: group.id }));
+    expect(tree.getLayers()).toHaveLength(2);
+    expect(tree.getLayers()[0]?.id).toBe(l1.id);
+
+    undoLast();
+    expect(tree.getLayers()).toHaveLength(1);
+    expect(tree.getLayers()[0]?.type).toBe('group');
+    expect(tree.getLayers()[0]?.children).toHaveLength(2);
+  });
+});
+
+describe('duplicate_layer command', () => {
+  it('should duplicate and undo', () => {
+    const layer = tree.addLayer('Original');
+    dispatch(makeCommand('duplicate_layer', { id: layer.id }));
+    expect(tree.getLayers()).toHaveLength(2);
+
+    undoLast();
+    expect(tree.getLayers()).toHaveLength(1);
+    expect(tree.getLayers()[0]?.id).toBe(layer.id);
+  });
+});
+
+describe('toggle_expanded command', () => {
+  it('should toggle and undo (toggle again)', () => {
+    tree.addLayer('Pixel'); // need at least one pixel layer for active
+    const group = tree.addGroup('Group');
+    expect(group.expanded).toBe(true);
+
+    dispatch(makeCommand('toggle_expanded', { id: group.id }));
+    expect(group.expanded).toBe(false);
+
+    undoLast();
+    expect(group.expanded).toBe(true);
+  });
+});

package/src/lib/layers/layer-commands.ts

@@ -0,0 +1,429 @@
+/**
+ * Layer Commands Plugin -- registers layer operations as undoable commands.
+ *
+ * Each command returns a snapshot from execute() that undo() uses to restore state.
+ * The layer tree module is imported directly (module-level singleton).
+ */
+
+import type { PluginModule } from '../core/plugin-loader.js';
+import type { Layer, BlendMode } from './layer-types.js';
+import * as tree from './layer-tree.svelte.js';
+import { notificationState } from '../core/notification-state.svelte.js';
+
+/** Snapshot of a removed layer's position for undo restore. */
+interface LayerPosition {
+  parentId: string | null;
+  index: number;
+}
+
+/** Find the parent ID and index of a layer in the tree. */
+function getLayerPosition(id: string): LayerPosition {
+  const parent = tree.getParent(id);
+  const siblings = parent?.children ?? tree.getLayers();
+  const index = siblings.findIndex((l) => l.id === id);
+  return {
+    parentId: parent?.id ?? null,
+    index,
+  };
+}
+
+/** Deep-clone a layer for snapshot storage (plain object, no references). */
+function snapshotLayer(layer: Layer): Layer {
+  const snap: Layer = { ...layer };
+  if (layer.children) {
+    snap.children = layer.children.map(snapshotLayer);
+  }
+  return snap;
+}
+
+/** Re-insert a snapshot layer at the given position.
+ *
+ * If the original parent group no longer exists (e.g. the user deleted the
+ * parent group after the layer was deleted, then undid the layer deletion),
+ * fall back to inserting at the root so the layer is not silently dropped.
+ * A warning notification is surfaced so the user knows the position changed.
+ */
+function restoreLayer(snapshot: Layer, position: LayerPosition): void {
+  let siblings: Layer[] | undefined = position.parentId
+    ? tree.getLayer(position.parentId)?.children
+    : tree.getLayers();
+  let index = position.index;
+
+  if (!siblings) {
+    // Parent group was removed between delete and undo -- fall back to root
+    // instead of silently dropping the restored layer.
+    siblings = tree.getLayers();
+    index = siblings.length;
+    notificationState.push({
+      id: `restore-layer-orphan-${snapshot.id}`,
+      message: 'Parent group for restored layer no longer exists; placed at root instead.',
+      type: 'warning',
+      autoDismissMs: 5000,
+    });
+  }
+
+  siblings.splice(index, 0, snapshot);
+}
+
+// --- Snapshot types for each command ---
+
+type AddLayerSnapshot = { previousActiveLayerId: string | null };
+type RemoveLayerSnapshot = {
+  layer: Layer;
+  position: LayerPosition;
+  previousActiveLayerId: string | null;
+};
+type RenameLayerSnapshot = { oldName: string };
+type MoveLayerSnapshot = { oldPosition: LayerPosition };
+type SetVisibilitySnapshot = { oldVisible: boolean };
+type SetOpacitySnapshot = { oldOpacity: number };
+type SetBlendModeSnapshot = { oldBlendMode: BlendMode };
+type SetLockedSnapshot = { oldLocked: boolean };
+type SetActiveLayerSnapshot = { oldActiveLayerId: string | null };
+type GroupLayersSnapshot = {
+  groupId: string;
+  previousActiveLayerId: string | null;
+};
+type UngroupLayerSnapshot = {
+  group: Layer;
+  position: LayerPosition;
+  previousActiveLayerId: string | null;
+};
+type DuplicateLayerSnapshot = {
+  cloneId: string;
+  previousActiveLayerId: string | null;
+};
+
+export const layerCommandsPlugin: PluginModule = {
+  name: 'builtin/layers',
+  version: '1.0.0',
+  description: 'Layer management commands',
+  dependencies: [],
+
+  register(api) {
+    // --- add_layer ---
+    api.addCommand('add_layer', {
+      tier: 'project',
+      execute(params) {
+        const previousActiveLayerId = tree.getActiveLayerId();
+        // Build options without undefined values (exactOptionalPropertyTypes)
+        const addOptions: { parentId?: string; index?: number; id?: string } = {};
+        if (params["parentId"] !== undefined) addOptions.parentId = params["parentId"];
+        if (params["index"] !== undefined) addOptions.index = params["index"];
+        if (params["id"] !== undefined) addOptions.id = params["id"];
+        const layer = tree.addLayer(params["name"], addOptions);
+        // Store the created layer's ID for undo (and to keep params stable on redo)
+        params["id"] = layer.id;
+        const snapshot: AddLayerSnapshot = { previousActiveLayerId };
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const typed = snapshot as AddLayerSnapshot | undefined;
+        tree.removeLayer(params["id"]!);
+        // Restore previous active layer
+        const previousActive = typed?.previousActiveLayerId;
+        if (previousActive && tree.getLayer(previousActive)) {
+          const layer = tree.getLayer(previousActive);
+          if (layer?.type === 'pixel') {
+            tree.setActiveLayer(previousActive);
+          }
+        }
+      },
+      describe(params) {
+        return `Added layer "${String(params["name"])}"`;
+      },
+    });
+
+    // --- remove_layer ---
+    api.addCommand('remove_layer', {
+      tier: 'project',
+      execute(params) {
+        const layer = tree.getLayer(params["id"]);
+        if (!layer) return;
+        // Stash name on params so describe() can use it (describe only gets params)
+        params["_removedName"] = layer.name;
+        // Snapshot the layer and its position for undo
+        const snapshot: RemoveLayerSnapshot = {
+          layer: snapshotLayer(layer),
+          position: getLayerPosition(params["id"]),
+          previousActiveLayerId: tree.getActiveLayerId(),
+        };
+        tree.removeLayer(params["id"]);
+        return snapshot;
+      },
+      undo(_params, _ctx, snapshot) {
+        const typed = snapshot as RemoveLayerSnapshot | undefined;
+        if (!typed) return;
+        restoreLayer(typed.layer, typed.position);
+        // Restore previous active layer
+        const previousActive = typed.previousActiveLayerId;
+        if (previousActive && tree.getLayer(previousActive)) {
+          const layer = tree.getLayer(previousActive);
+          if (layer?.type === 'pixel') {
+            tree.setActiveLayer(previousActive);
+          }
+        }
+      },
+      describe(params) {
+        return `Removed layer "${String(params["_removedName"] ?? params["id"])}"`;
+      },
+    });
+
+    // --- rename_layer ---
+    api.addCommand('rename_layer', {
+      tier: 'project',
+      execute(params) {
+        const layer = tree.getLayer(params["id"]);
+        if (!layer) return;
+        const snapshot: RenameLayerSnapshot = { oldName: layer.name };
+        tree.renameLayer(params["id"], params["name"]);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const typed = snapshot as RenameLayerSnapshot | undefined;
+        if (!typed) return;
+        tree.renameLayer(params["id"], typed.oldName);
+      },
+      describe(params) {
+        return `Renamed layer to "${String(params["name"])}"`;
+      },
+    });
+
+    // --- move_layer ---
+    api.addCommand('move_layer', {
+      tier: 'project',
+      execute(params) {
+        // Capture old position for undo
+        const snapshot: MoveLayerSnapshot = {
+          oldPosition: getLayerPosition(params["id"]),
+        };
+        tree.moveLayer(
+          params["id"],
+          params["newParentId"] ?? null,
+          params["newIndex"],
+        );
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const typed = snapshot as MoveLayerSnapshot | undefined;
+        if (!typed) return;
+        tree.moveLayer(params["id"], typed.oldPosition.parentId, typed.oldPosition.index);
+      },
+      describe(params) {
+        return `Moved layer "${String(params["id"])}"`;
+      },
+    });
+
+    // --- set_layer_visibility ---
+    api.addCommand('set_layer_visibility', {
+      tier: 'project',
+      execute(params) {
+        const layer = tree.getLayer(params["id"]);
+        if (!layer) return;
+        const snapshot: SetVisibilitySnapshot = { oldVisible: layer.visible };
+        tree.setVisibility(params["id"], params["visible"]);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const typed = snapshot as SetVisibilitySnapshot | undefined;
+        if (!typed) return;
+        tree.setVisibility(params["id"], typed.oldVisible);
+      },
+      describe(params) {
+        return params["visible"] ? `Showed layer` : `Hid layer`;
+      },
+    });
+
+    // --- set_layer_opacity ---
+    api.addCommand('set_layer_opacity', {
+      tier: 'project',
+      execute(params) {
+        const layer = tree.getLayer(params["id"]);
+        if (!layer) return;
+        const snapshot: SetOpacitySnapshot = { oldOpacity: layer.opacity };
+        tree.setOpacity(params["id"], params["opacity"]);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const typed = snapshot as SetOpacitySnapshot | undefined;
+        if (!typed) return;
+        tree.setOpacity(params["id"], typed.oldOpacity);
+      },
+      describe(params) {
+        return `Set layer opacity to ${String(params["opacity"])}%`;
+      },
+    });
+
+    // --- set_layer_blend_mode ---
+    api.addCommand('set_layer_blend_mode', {
+      tier: 'project',
+      execute(params) {
+        const layer = tree.getLayer(params["id"]);
+        if (!layer) return;
+        const snapshot: SetBlendModeSnapshot = { oldBlendMode: layer.blendMode };
+        tree.setBlendMode(params["id"], params["mode"] as BlendMode);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const typed = snapshot as SetBlendModeSnapshot | undefined;
+        if (!typed) return;
+        tree.setBlendMode(params["id"], typed.oldBlendMode);
+      },
+      describe(params) {
+        return `Set blend mode to "${String(params["mode"])}"`;
+      },
+    });
+
+    // --- set_layer_locked ---
+    api.addCommand('set_layer_locked', {
+      tier: 'project',
+      execute(params) {
+        const layer = tree.getLayer(params["id"]);
+        if (!layer) return;
+        const snapshot: SetLockedSnapshot = { oldLocked: layer.locked };
+        tree.setLocked(params["id"], params["locked"]);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const typed = snapshot as SetLockedSnapshot | undefined;
+        if (!typed) return;
+        tree.setLocked(params["id"], typed.oldLocked);
+      },
+      describe(params) {
+        return params["locked"] ? 'Locked layer' : 'Unlocked layer';
+      },
+    });
+
+    // --- set_active_layer ---
+    api.addCommand('set_active_layer', {
+      tier: 'project',
+      execute(params) {
+        const snapshot: SetActiveLayerSnapshot = {
+          oldActiveLayerId: tree.getActiveLayerId(),
+        };
+        tree.setActiveLayer(params["id"]);
+        return snapshot;
+      },
+      undo(_params, _ctx, snapshot) {
+        const typed = snapshot as SetActiveLayerSnapshot | undefined;
+        if (!typed) return;
+        const oldId = typed.oldActiveLayerId;
+        if (oldId && tree.getLayer(oldId)?.type === 'pixel') {
+          tree.setActiveLayer(oldId);
+        }
+      },
+      describe() {
+        return 'Changed active layer';
+      },
+    });
+
+    // --- group_layers ---
+    api.addCommand('group_layers', {
+      tier: 'project',
+      execute(params) {
+        const ids = params["ids"];
+        const previousActiveLayerId = tree.getActiveLayerId();
+        const group = tree.groupLayers(ids, params["groupName"]);
+        const snapshot: GroupLayersSnapshot = {
+          groupId: group.id,
+          previousActiveLayerId,
+        };
+        return snapshot;
+      },
+      undo(_params, _ctx, snapshot) {
+        const typed = snapshot as GroupLayersSnapshot | undefined;
+        if (!typed) return;
+        // Ungroup, then restore original positions
+        tree.ungroupLayer(typed.groupId);
+        // Restore active layer
+        const previousActive = typed.previousActiveLayerId;
+        if (previousActive && tree.getLayer(previousActive)?.type === 'pixel') {
+          tree.setActiveLayer(previousActive);
+        }
+      },
+      describe(params) {
+        return `Grouped layers into "${String(params["groupName"])}"`;
+      },
+    });
+
+    // --- ungroup_layer ---
+    api.addCommand('ungroup_layer', {
+      tier: 'project',
+      execute(params) {
+        const group = tree.getLayer(params["id"]);
+        if (!group || group.type !== 'group') return;
+        // Stash name on params so describe() can use it (describe only gets params)
+        params["_removedName"] = group.name;
+        // Snapshot the group for undo
+        const snapshot: UngroupLayerSnapshot = {
+          group: snapshotLayer(group),
+          position: getLayerPosition(params["id"]),
+          previousActiveLayerId: tree.getActiveLayerId(),
+        };
+        tree.ungroupLayer(params["id"]);
+        return snapshot;
+      },
+      undo(_params, _ctx, snapshot) {
+        const typed = snapshot as UngroupLayerSnapshot | undefined;
+        if (!typed) return;
+
+        // Remove the children that were flattened out
+        const childIds = typed.group.children?.map((c) => c.id) ?? [];
+        for (const childId of childIds) {
+          tree.removeLayer(childId);
+        }
+        // Restore the group
+        restoreLayer(typed.group, typed.position);
+        // Restore active layer
+        const previousActive = typed.previousActiveLayerId;
+        if (previousActive && tree.getLayer(previousActive)?.type === 'pixel') {
+          tree.setActiveLayer(previousActive);
+        }
+      },
+      describe(params) {
+        return `Ungrouped "${String(params["_removedName"] ?? params["id"])}"`;
+      },
+    });
+
+    // --- duplicate_layer ---
+    api.addCommand('duplicate_layer', {
+      tier: 'project',
+      execute(params) {
+        const previousActiveLayerId = tree.getActiveLayerId();
+        const clone = tree.duplicateLayer(params["id"]);
+        const snapshot: DuplicateLayerSnapshot = {
+          cloneId: clone.id,
+          previousActiveLayerId,
+        };
+        return snapshot;
+      },
+      undo(_params, _ctx, snapshot) {
+        const typed = snapshot as DuplicateLayerSnapshot | undefined;
+        if (!typed) return;
+        tree.removeLayer(typed.cloneId);
+        const previousActive = typed.previousActiveLayerId;
+        if (previousActive && tree.getLayer(previousActive)?.type === 'pixel') {
+          tree.setActiveLayer(previousActive);
+        }
+      },
+      describe() {
+        return `Duplicated layer`;
+      },
+    });
+
+    // --- toggle_expanded ---
+    api.addCommand('toggle_expanded', {
+      tier: 'project',
+      execute(params) {
+        tree.toggleExpanded(params["id"]);
+      },
+      undo(params) {
+        // Toggle is its own inverse
+        tree.toggleExpanded(params["id"]);
+      },
+      describe() {
+        return 'Toggled group expansion';
+      },
+    });
+  },
+};