@pixerate/editor 0.227.1 → 0.228.0

package/dist/{chunk-53GOGBTM.cjs → chunk-CHAWTXBE.cjs}

@@ -1,7 +1,16 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
-var _chunk4EFNS2HVcjs = require('./chunk-4EFNS2HV.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkT7QSEKDYcjs = require('./chunk-T7QSEKDY.cjs');
 
 // src/commands/builtins.ts
 var DEFAULT_HISTORY_SHORTCUTS = [
@@ -46,7 +55,7 @@ function createHistoryCommands(history, options = {}) {
 }
 var historyShortcutMap = null;
 function matchHistoryShortcut(event, options = {}) {
-  historyShortcutMap ??= new (0, _chunk4EFNS2HVcjs.ShortcutMap)(DEFAULT_HISTORY_SHORTCUTS);
+  historyShortcutMap ??= new (0, _chunkT7QSEKDYcjs.ShortcutMap)(DEFAULT_HISTORY_SHORTCUTS);
   return _nullishCoalesce(_optionalChain([historyShortcutMap, 'access', _2 => _2.resolve, 'call', _3 => _3(event, options), 'optionalAccess', _4 => _4.command]), () => ( null));
 }
 var ARRANGE_LABELS = {
@@ -81,7 +90,7 @@ function createArrangeCommands(controller, options = {}) {
   const prefix = _nullishCoalesce(options.prefix, () => ( "canvas."));
   const group = _nullishCoalesce(options.group, () => ( "Arrange"));
   const scope = options.scope === null ? void 0 : _nullishCoalesce(options.scope, () => ( "canvas"));
-  const bindings = _nullishCoalesce(options.bindings, () => ( _chunk4EFNS2HVcjs.DEFAULT_ARRANGE_SHORTCUTS));
+  const bindings = _nullishCoalesce(options.bindings, () => ( _chunkT7QSEKDYcjs.DEFAULT_ARRANGE_SHORTCUTS));
   const count = (params) => _nullishCoalesce(_optionalChain([params, 'optionalAccess', _5 => _5.ids, 'optionalAccess', _6 => _6.length]), () => ( _optionalChain([options, 'access', _7 => _7.getSelectedIds, 'optionalCall', _8 => _8(), 'access', _9 => _9.length])));
   const needs = (min, what) => (_, params) => {
     const n = count(params);
@@ -370,7 +379,202 @@ function createDrawCommands(target, options = {}) {
       params: { type: "object", additionalProperties: false, properties: {} },
       readOnly: true,
       run: async () => ({ brushes: await target.listBrushes() })
+    },
+    ...createGestureCommands(target, base, prefix, options)
+  ];
+}
+var GESTURE_RECT_PARAM = {
+  type: "object",
+  additionalProperties: false,
+  required: ["x", "y", "width", "height"],
+  description: "A box in canvas units (top left x, y and its size), e.g. a node's bounds from get_editor_state or a stroke's `bounds`.",
+  properties: {
+    x: { type: "number", description: "Left edge, canvas units." },
+    y: { type: "number", description: "Top edge, canvas units." },
+    width: { type: "number", minimum: 0, description: "Width, canvas units." },
+    height: { type: "number", minimum: 0, description: "Height, canvas units." }
+  }
+};
+var GESTURE_NODE_PARAM = {
+  type: "object",
+  additionalProperties: false,
+  required: ["nodeId"],
+  description: "A node on the canvas by id; its current box is used, so you need not read its position first.",
+  properties: { nodeId: { type: "string", minLength: 1, description: "The node id (from get_editor_state or a result)." } }
+};
+var GESTURE_POINT_PARAM = {
+  type: "array",
+  minItems: 2,
+  maxItems: 2,
+  items: { type: "number" },
+  description: "A point as [x, y] in canvas units."
+};
+var gestureBox = (what) => ({ description: what, oneOf: [GESTURE_RECT_PARAM, GESTURE_NODE_PARAM] });
+var gestureEnd = (what) => ({ description: what, oneOf: [GESTURE_RECT_PARAM, GESTURE_NODE_PARAM, GESTURE_POINT_PARAM] });
+var gestureBoxes = (what) => ({
+  type: "array",
+  minItems: 1,
+  maxItems: 100,
+  items: { oneOf: [GESTURE_RECT_PARAM, GESTURE_NODE_PARAM] },
+  description: `${what} Each is a box { x, y, width, height } or a node { nodeId }; the gesture spans the box around all of them.`
+});
+var GESTURE_STYLE_PARAMS = {
+  tool: { type: "string", enum: ["pen", "highlighter"], description: "Pen (default: blue, width 3) or highlighter (yellow, width 24, opacity 0.35); sets the defaults below." },
+  color: { type: "string", description: "Stroke colour, any CSS colour (default from the tool)." },
+  width: { type: "number", exclusiveMinimum: 0, maximum: 2500, description: "Stroke width in canvas units (default from the tool; with a brush, the preset's own size)." },
+  opacity: { type: "number", minimum: 0, maximum: 1, description: "Stroke opacity 0..1 (default from the tool)." },
+  brush: {
+    description: 'Paint the mark with a dry paint brush: a preset id such as "ink-pen", "marker", "pencil-hb" or "brush-pen" (all ids: canvas.listBrushes), or tip settings. Brushed marks get an uneven hand pressure. Omit for a plain vector stroke.',
+    oneOf: [{ type: "string", minLength: 1 }, BRUSH_SETTINGS_PARAM]
+  },
+  seed: { type: "integer", minimum: 0, maximum: 4294967295, description: "Seed for the hand-drawn wobble (default: derived from the other params, so the same request draws the same mark). Change it for a different take." }
+};
+function createGestureCommands(target, base, prefix, options) {
+  const box = (value, name) => {
+    if (Array.isArray(value)) throw new Error(`${name} must be a box { x, y, width, height } or a node { nodeId }, not a point.`);
+    if ("nodeId" in value) {
+      if (!target.nodeBounds) throw new Error(`This canvas cannot look up nodes: pass ${name} as a box { x, y, width, height } (a node's bounds from get_editor_state).`);
+      const rect = target.nodeBounds(value.nodeId);
+      if (!rect) throw new Error(`Unknown node "${value.nodeId}" in ${name}: use an id from get_editor_state.`);
+      return rect;
     }
+    return value;
+  };
+  const end = (value, name) => Array.isArray(value) ? [value[0], value[1]] : box(value, name);
+  const boxes = (values, name) => _chunkT7QSEKDYcjs.gestureUnion.call(void 0, values.map((v, i) => box(v, `${name}[${i}]`)));
+  const gesture = (spec) => {
+    const seedOf = (params) => _nullishCoalesce(params.seed, () => ( _chunkT7QSEKDYcjs.gestureSeed.call(void 0, { gesture: spec.name, ...params })));
+    const generate = (params) => {
+      const seed = seedOf(params);
+      return { seed, stroke: spec.make(params, seed) };
+    };
+    return {
+      ...base,
+      id: `${prefix}${spec.name}`,
+      label: spec.label,
+      keywords: ["annotate", "mark up", "hand-drawn", ...spec.keywords],
+      description: `${spec.description} Drawn as one hand-drawn pen or highlighter stroke node (one undo step), with a seeded wobble. Returns the new node \`id\`, its \`bounds\`, the stored \`brush\` (when brushed) and the \`seed\` used.`,
+      params: {
+        type: "object",
+        additionalProperties: false,
+        required: spec.required,
+        properties: { ...spec.properties, ...GESTURE_STYLE_PARAMS }
+      },
+      enabled: () => _optionalChain([options, 'access', _31 => _31.readOnlyReason, 'optionalCall', _32 => _32()]) || true,
+      plan: (_ctx, params) => {
+        try {
+          return planFreehandPlayback(generate(params).stroke.points);
+        } catch (e) {
+          return null;
+        }
+      },
+      run: async (_ctx, params) => {
+        const { seed, stroke } = generate(params);
+        const result = await target.drawStroke({
+          points: stroke.points,
+          ...params.tool ? { tool: params.tool } : {},
+          style: {
+            ...params.color !== void 0 ? { color: params.color } : {},
+            ...params.width !== void 0 ? { width: params.width } : {},
+            ...params.width !== void 0 && params.brush !== void 0 ? { brushSize: params.width } : {},
+            ...params.opacity !== void 0 ? { opacity: params.opacity } : {},
+            ...params.brush !== void 0 ? { brush: params.brush } : {}
+          },
+          ...params.brush !== void 0 ? { pressure: stroke.pressure } : {}
+        });
+        return { ...result, seed };
+      }
+    };
+  };
+  return [
+    gesture({
+      name: "circle",
+      label: "Circle Around",
+      keywords: ["circle", "ring", "loop", "highlight", "pick", "ellipse"],
+      description: "Circles boxes or nodes with a loose, slightly open ellipse that never cuts into them: the way to point out a pick or the thing you are talking about.",
+      required: ["around"],
+      properties: {
+        around: gestureBoxes("What to circle."),
+        padding: { type: "number", minimum: 0, maximum: 500, description: "Space between them and the loop, canvas units (default 8)." }
+      },
+      make: (p, seed) => _chunkT7QSEKDYcjs.circleGesture.call(void 0, boxes(p.around, "around"), seed, { ...p.padding !== void 0 ? { padding: p.padding } : {} })
+    }),
+    gesture({
+      name: "underline",
+      label: "Underline",
+      keywords: ["underline", "emphasis", "line under", "squiggle"],
+      description: "Underlines a box or node with a stroke just below its bottom edge, a little longer or shorter than it: for stressing a line of text or a value.",
+      required: ["under"],
+      properties: {
+        under: gestureBox("What to underline: a box { x, y, width, height } or a node { nodeId }."),
+        offset: { type: "number", minimum: 0, maximum: 200, description: "Gap below the bottom edge, canvas units (default 4)." },
+        wave: { type: "boolean", description: "A wavy (squiggly) underline instead of a straight one (default false)." }
+      },
+      make: (p, seed) => _chunkT7QSEKDYcjs.underlineGesture.call(void 0, box(p.under, "under"), seed, { ...p.offset !== void 0 ? { offset: p.offset } : {}, ...p.wave ? { wave: true } : {} })
+    }),
+    gesture({
+      name: "arrow",
+      label: "Arrow",
+      keywords: ["arrow", "point", "connect", "from", "to", "pointer"],
+      description: "Draws a curved arrow with a hand-drawn head from one thing to another: a box or node is reached at its nearest edge, a point exactly. For linking a swatch to where it is used, or pointing from a note to its subject.",
+      required: ["from", "to"],
+      properties: {
+        from: gestureEnd("Where the arrow starts: a box, a node { nodeId } or a point [x, y]."),
+        to: gestureEnd("Where the arrow points: a box, a node { nodeId } or a point [x, y]."),
+        curve: { type: "number", minimum: -1, maximum: 1, description: "Bend of the shaft \u22121..1: how far its middle bulges, as a fraction of half its length; positive bends to the left of travel, 0 is straight (default: a gentle seeded bend, about 0.1)." },
+        gap: { type: "number", minimum: 0, maximum: 200, description: "Space between a box end and the arrow, canvas units (default 6)." }
+      },
+      make: (p, seed) => _chunkT7QSEKDYcjs.arrowGesture.call(void 0, end(p.from, "from"), end(p.to, "to"), seed, { ...p.curve !== void 0 ? { curve: p.curve } : {}, ...p.gap !== void 0 ? { gap: p.gap } : {} })
+    }),
+    gesture({
+      name: "bracket",
+      label: "Bracket",
+      keywords: ["bracket", "brace", "group", "curly", "span"],
+      description: "Brackets boxes or nodes on one side with a curly or square bracket spanning them end to end: for grouping a set of items or a range of lines, usually with a note beside it.",
+      required: ["around", "side"],
+      properties: {
+        around: gestureBoxes("What to bracket."),
+        side: { type: "string", enum: ["left", "right", "top", "bottom"], description: "Which side the bracket goes on." },
+        shape: { type: "string", enum: ["curly", "square"], description: "Curly brace (default) or square bracket." },
+        padding: { type: "number", minimum: 0, maximum: 500, description: "Gap between them and the bracket, canvas units (default 8)." },
+        depth: { type: "number", exclusiveMinimum: 0, maximum: 500, description: "How far the bracket reaches out, canvas units (default: from the span, 6..20)." }
+      },
+      make: (p, seed) => _chunkT7QSEKDYcjs.bracketGesture.call(void 0, boxes(p.around, "around"), p.side, seed, {
+        ...p.shape ? { shape: p.shape } : {},
+        ...p.padding !== void 0 ? { padding: p.padding } : {},
+        ...p.depth !== void 0 ? { depth: p.depth } : {}
+      })
+    }),
+    gesture({
+      name: "strike",
+      label: "Strike Through",
+      keywords: ["strike", "strikethrough", "cross out", "line through", "delete"],
+      description: "Strikes a line through the middle of a box or node, a little past both ends: for text or a value to drop. It only marks it; nothing is deleted.",
+      required: ["over"],
+      properties: { over: gestureBox("What to strike through: a box { x, y, width, height } or a node { nodeId }.") },
+      make: (p, seed) => _chunkT7QSEKDYcjs.strikeGesture.call(void 0, box(p.over, "over"), seed)
+    }),
+    gesture({
+      name: "cross",
+      label: "Cross Out",
+      keywords: ["cross", "x", "reject", "no", "wrong", "cross out"],
+      description: "Crosses out a box or node with an X from corner to corner: for a rejected option. It only marks it; nothing is deleted. One stroke, so the pen runs back over part of the first diagonal before drawing the second.",
+      required: ["over"],
+      properties: { over: gestureBox("What to cross out: a box { x, y, width, height } or a node { nodeId }.") },
+      make: (p, seed) => _chunkT7QSEKDYcjs.crossGesture.call(void 0, box(p.over, "over"), seed)
+    }),
+    gesture({
+      name: "check",
+      label: "Check Mark",
+      keywords: ["check", "tick", "approve", "yes", "done", "ok"],
+      description: "Draws a tick mark in the middle of a box or node, or centred on a point: for an approved option or a done item.",
+      required: ["at"],
+      properties: {
+        at: gestureEnd("Where the tick goes: a box, a node { nodeId } (its centre) or a point [x, y]."),
+        size: { type: "number", exclusiveMinimum: 0, maximum: 2e3, description: "Height of the tick, canvas units (default: 60% of the box's smaller side, 12..48; 20 at a point)." }
+      },
+      make: (p, seed) => _chunkT7QSEKDYcjs.checkGesture.call(void 0, end(p.at, "at"), seed, { ...p.size !== void 0 ? { size: p.size } : {} })
+    })
   ];
 }
 function hasVariantCommands(controller) {
@@ -401,15 +605,15 @@ function variantCommands(controller, prefix, base) {
           y: { type: "number", description: "Y in the set\u2019s space." }
         }
       },
-      enabled: (_ctx, params) => controller.canAddVariant(_optionalChain([params, 'optionalAccess', _31 => _31.setId]), {
-        ..._optionalChain([params, 'optionalAccess', _32 => _32.from]) !== void 0 ? { from: params.from } : {},
-        ..._optionalChain([params, 'optionalAccess', _33 => _33.variant]) ? { variant: params.variant } : {}
+      enabled: (_ctx, params) => controller.canAddVariant(_optionalChain([params, 'optionalAccess', _33 => _33.setId]), {
+        ..._optionalChain([params, 'optionalAccess', _34 => _34.from]) !== void 0 ? { from: params.from } : {},
+        ..._optionalChain([params, 'optionalAccess', _35 => _35.variant]) ? { variant: params.variant } : {}
       }),
       run: (_ctx, params) => outcome(
-        controller.addVariant(_optionalChain([params, 'optionalAccess', _34 => _34.setId]), {
-          ..._optionalChain([params, 'optionalAccess', _35 => _35.from]) !== void 0 ? { from: params.from } : {},
-          ..._optionalChain([params, 'optionalAccess', _36 => _36.variant]) ? { variant: params.variant } : {},
-          ..._optionalChain([params, 'optionalAccess', _37 => _37.x]) !== void 0 || _optionalChain([params, 'optionalAccess', _38 => _38.y]) !== void 0 ? { position: { x: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _39 => _39.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _40 => _40.y]), () => ( 0)) } } : {}
+        controller.addVariant(_optionalChain([params, 'optionalAccess', _36 => _36.setId]), {
+          ..._optionalChain([params, 'optionalAccess', _37 => _37.from]) !== void 0 ? { from: params.from } : {},
+          ..._optionalChain([params, 'optionalAccess', _38 => _38.variant]) ? { variant: params.variant } : {},
+          ..._optionalChain([params, 'optionalAccess', _39 => _39.x]) !== void 0 || _optionalChain([params, 'optionalAccess', _40 => _40.y]) !== void 0 ? { position: { x: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _41 => _41.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _42 => _42.y]), () => ( 0)) } } : {}
         })
       )
     },
@@ -420,8 +624,8 @@ function variantCommands(controller, prefix, base) {
       keywords: ["delete variant", "variant"],
       description: "Removes a variant; its instances switch to the closest remaining variant, keeping overrides.",
       params: { type: "object", properties: { id: VARIANT_ID_PARAM } },
-      enabled: (_ctx, params) => controller.canRemoveVariant(_optionalChain([params, 'optionalAccess', _41 => _41.id])),
-      run: (_ctx, params) => outcome(controller.removeVariant(_optionalChain([params, 'optionalAccess', _42 => _42.id])))
+      enabled: (_ctx, params) => controller.canRemoveVariant(_optionalChain([params, 'optionalAccess', _43 => _43.id])),
+      run: (_ctx, params) => outcome(controller.removeVariant(_optionalChain([params, 'optionalAccess', _44 => _44.id])))
     },
     {
       ...base,
@@ -430,8 +634,8 @@ function variantCommands(controller, prefix, base) {
       keywords: ["rename variant", "variant values", "variant"],
       description: "Sets a variant\u2019s property values (refusing a combination another variant has).",
       params: { type: "object", properties: { values: VARIANT_VALUES_PARAM, id: VARIANT_ID_PARAM }, required: ["values"] },
-      enabled: (_ctx, params) => controller.canSetVariantProperties(_optionalChain([params, 'optionalAccess', _43 => _43.values]), _optionalChain([params, 'optionalAccess', _44 => _44.id])),
-      run: (_ctx, params) => outcome(controller.setVariantProperties(params.values, _optionalChain([params, 'optionalAccess', _45 => _45.id])))
+      enabled: (_ctx, params) => controller.canSetVariantProperties(_optionalChain([params, 'optionalAccess', _45 => _45.values]), _optionalChain([params, 'optionalAccess', _46 => _46.id])),
+      run: (_ctx, params) => outcome(controller.setVariantProperties(params.values, _optionalChain([params, 'optionalAccess', _47 => _47.id])))
     },
     {
       ...base,
@@ -444,8 +648,8 @@ function variantCommands(controller, prefix, base) {
         properties: { name: { type: "string" }, newName: { type: "string" }, setId: SET_ID_PARAM },
         required: ["name", "newName"]
       },
-      enabled: (_ctx, params) => controller.canRenameVariantProperty(_optionalChain([params, 'optionalAccess', _46 => _46.name]), _optionalChain([params, 'optionalAccess', _47 => _47.newName]), _optionalChain([params, 'optionalAccess', _48 => _48.setId])),
-      run: (_ctx, params) => outcome(controller.renameVariantProperty(params.name, params.newName, _optionalChain([params, 'optionalAccess', _49 => _49.setId])))
+      enabled: (_ctx, params) => controller.canRenameVariantProperty(_optionalChain([params, 'optionalAccess', _48 => _48.name]), _optionalChain([params, 'optionalAccess', _49 => _49.newName]), _optionalChain([params, 'optionalAccess', _50 => _50.setId])),
+      run: (_ctx, params) => outcome(controller.renameVariantProperty(params.name, params.newName, _optionalChain([params, 'optionalAccess', _51 => _51.setId])))
     },
     {
       ...base,
@@ -458,8 +662,8 @@ function variantCommands(controller, prefix, base) {
         properties: { property: { type: "string" }, value: { type: "string" }, newValue: { type: "string" }, setId: SET_ID_PARAM },
         required: ["property", "value", "newValue"]
       },
-      enabled: (_ctx, params) => controller.canRenameVariantValue(_optionalChain([params, 'optionalAccess', _50 => _50.property]), _optionalChain([params, 'optionalAccess', _51 => _51.value]), _optionalChain([params, 'optionalAccess', _52 => _52.newValue]), _optionalChain([params, 'optionalAccess', _53 => _53.setId])),
-      run: (_ctx, params) => outcome(controller.renameVariantValue(params.property, params.value, params.newValue, _optionalChain([params, 'optionalAccess', _54 => _54.setId])))
+      enabled: (_ctx, params) => controller.canRenameVariantValue(_optionalChain([params, 'optionalAccess', _52 => _52.property]), _optionalChain([params, 'optionalAccess', _53 => _53.value]), _optionalChain([params, 'optionalAccess', _54 => _54.newValue]), _optionalChain([params, 'optionalAccess', _55 => _55.setId])),
+      run: (_ctx, params) => outcome(controller.renameVariantValue(params.property, params.value, params.newValue, _optionalChain([params, 'optionalAccess', _56 => _56.setId])))
     }
   ];
 }
@@ -483,8 +687,8 @@ function createComponentCommands(controller, options = {}) {
       description: "Turns the selected frame into a main component, or wraps the selection in one.",
       params: IDS_PARAMS,
       shortcut: "Mod+Alt+K",
-      enabled: (_ctx, params) => controller.canCreateComponent(_optionalChain([params, 'optionalAccess', _55 => _55.ids])),
-      run: (_ctx, params) => outcome(controller.createComponent(_optionalChain([params, 'optionalAccess', _56 => _56.ids])))
+      enabled: (_ctx, params) => controller.canCreateComponent(_optionalChain([params, 'optionalAccess', _57 => _57.ids])),
+      run: (_ctx, params) => outcome(controller.createComponent(_optionalChain([params, 'optionalAccess', _58 => _58.ids])))
     },
     {
       ...base,
@@ -493,8 +697,8 @@ function createComponentCommands(controller, options = {}) {
       keywords: ["component set", "variant", "variants"],
       description: "Wraps the selected components in a component set.",
       params: IDS_PARAMS,
-      enabled: (_ctx, params) => controller.canCombineAsVariants(_optionalChain([params, 'optionalAccess', _57 => _57.ids])),
-      run: (_ctx, params) => outcome(controller.combineAsVariants(_optionalChain([params, 'optionalAccess', _58 => _58.ids])))
+      enabled: (_ctx, params) => controller.canCombineAsVariants(_optionalChain([params, 'optionalAccess', _59 => _59.ids])),
+      run: (_ctx, params) => outcome(controller.combineAsVariants(_optionalChain([params, 'optionalAccess', _60 => _60.ids])))
     },
     {
       ...base,
@@ -513,7 +717,7 @@ function createComponentCommands(controller, options = {}) {
         },
         required: ["componentId"]
       },
-      enabled: (_ctx, params) => _optionalChain([params, 'optionalAccess', _59 => _59.componentId]) === void 0 ? true : controller.canCreateInstance(params.componentId, params.parentId),
+      enabled: (_ctx, params) => _optionalChain([params, 'optionalAccess', _61 => _61.componentId]) === void 0 ? true : controller.canCreateInstance(params.componentId, params.parentId),
       run: (_ctx, params) => outcome(
         controller.createInstance(params.componentId, {
           ...params.parentId !== void 0 ? { parentId: params.parentId } : {},
@@ -530,8 +734,8 @@ function createComponentCommands(controller, options = {}) {
       description: "Turns the selected instances into plain frames that keep their look.",
       params: IDS_PARAMS,
       shortcut: "Mod+Alt+B",
-      enabled: (_ctx, params) => controller.canDetachInstance(_optionalChain([params, 'optionalAccess', _60 => _60.ids])),
-      run: (_ctx, params) => outcome(controller.detachInstance(_optionalChain([params, 'optionalAccess', _61 => _61.ids])))
+      enabled: (_ctx, params) => controller.canDetachInstance(_optionalChain([params, 'optionalAccess', _62 => _62.ids])),
+      run: (_ctx, params) => outcome(controller.detachInstance(_optionalChain([params, 'optionalAccess', _63 => _63.ids])))
     },
     {
       ...base,
@@ -546,8 +750,8 @@ function createComponentCommands(controller, options = {}) {
           group: { type: "string", description: 'One override group to reset, e.g. "data.label" or "shape.fill" (default: all).' }
         }
       },
-      enabled: (_ctx, params) => controller.canResetOverrides(_optionalChain([params, 'optionalAccess', _62 => _62.id])),
-      run: (_ctx, params) => outcome(controller.resetOverrides(_optionalChain([params, 'optionalAccess', _63 => _63.id]), _optionalChain([params, 'optionalAccess', _64 => _64.group])))
+      enabled: (_ctx, params) => controller.canResetOverrides(_optionalChain([params, 'optionalAccess', _64 => _64.id])),
+      run: (_ctx, params) => outcome(controller.resetOverrides(_optionalChain([params, 'optionalAccess', _65 => _65.id]), _optionalChain([params, 'optionalAccess', _66 => _66.group])))
     },
     {
       ...base,
@@ -556,8 +760,8 @@ function createComponentCommands(controller, options = {}) {
       keywords: ["push overrides", "update main component"],
       description: "Copies the instance\u2019s overrides to its main component and every other instance.",
       params: idParams,
-      enabled: (_ctx, params) => controller.canPushOverrides(_optionalChain([params, 'optionalAccess', _65 => _65.id])),
-      run: (_ctx, params) => outcome(controller.pushOverrides(_optionalChain([params, 'optionalAccess', _66 => _66.id])))
+      enabled: (_ctx, params) => controller.canPushOverrides(_optionalChain([params, 'optionalAccess', _67 => _67.id])),
+      run: (_ctx, params) => outcome(controller.pushOverrides(_optionalChain([params, 'optionalAccess', _68 => _68.id])))
     },
     {
       ...base,
@@ -566,9 +770,9 @@ function createComponentCommands(controller, options = {}) {
       keywords: ["main component", "find main", "reveal"],
       description: "Selects the main component of the selected instance.",
       params: idParams,
-      enabled: (_ctx, params) => controller.canGoToMainComponent(_optionalChain([params, 'optionalAccess', _67 => _67.id])),
+      enabled: (_ctx, params) => controller.canGoToMainComponent(_optionalChain([params, 'optionalAccess', _69 => _69.id])),
       run: (_ctx, params) => {
-        const main = controller.goToMainComponent(_optionalChain([params, 'optionalAccess', _68 => _68.id]));
+        const main = controller.goToMainComponent(_optionalChain([params, 'optionalAccess', _70 => _70.id]));
         if (!main) throw new Error("The main component was not found.");
         return { id: main };
       }
@@ -587,8 +791,8 @@ function createComponentCommands(controller, options = {}) {
         },
         required: ["componentId"]
       },
-      enabled: (_ctx, params) => controller.canSwapInstance(_optionalChain([params, 'optionalAccess', _69 => _69.componentId]), _optionalChain([params, 'optionalAccess', _70 => _70.ids])),
-      run: (_ctx, params) => outcome(controller.swapInstance(params.componentId, _optionalChain([params, 'optionalAccess', _71 => _71.ids])))
+      enabled: (_ctx, params) => controller.canSwapInstance(_optionalChain([params, 'optionalAccess', _71 => _71.componentId]), _optionalChain([params, 'optionalAccess', _72 => _72.ids])),
+      run: (_ctx, params) => outcome(controller.swapInstance(params.componentId, _optionalChain([params, 'optionalAccess', _73 => _73.ids])))
     },
     {
       ...base,
@@ -604,8 +808,8 @@ function createComponentCommands(controller, options = {}) {
         },
         required: ["properties"]
       },
-      enabled: (_ctx, params) => controller.canSetInstanceProperties(_optionalChain([params, 'optionalAccess', _72 => _72.ids])),
-      run: (_ctx, params) => outcome(controller.setInstanceProperties(params.properties, _optionalChain([params, 'optionalAccess', _73 => _73.ids])))
+      enabled: (_ctx, params) => controller.canSetInstanceProperties(_optionalChain([params, 'optionalAccess', _74 => _74.ids])),
+      run: (_ctx, params) => outcome(controller.setInstanceProperties(params.properties, _optionalChain([params, 'optionalAccess', _75 => _75.ids])))
     },
     {
       ...base,
@@ -614,8 +818,8 @@ function createComponentCommands(controller, options = {}) {
       keywords: ["missing main", "recover component"],
       description: "Turns an instance whose main was deleted back into the main component.",
       params: idParams,
-      enabled: (_ctx, params) => controller.canRestoreMainComponent(_optionalChain([params, 'optionalAccess', _74 => _74.id])),
-      run: (_ctx, params) => outcome(controller.restoreMainComponent(_optionalChain([params, 'optionalAccess', _75 => _75.id])))
+      enabled: (_ctx, params) => controller.canRestoreMainComponent(_optionalChain([params, 'optionalAccess', _76 => _76.id])),
+      run: (_ctx, params) => outcome(controller.restoreMainComponent(_optionalChain([params, 'optionalAccess', _77 => _77.id])))
     },
     {
       ...base,
@@ -634,8 +838,8 @@ function createComponentCommands(controller, options = {}) {
       description: "Describes an instance: its main, variant, property values and overrides.",
       params: idParams,
       readOnly: true,
-      enabled: (_ctx, params) => controller.inspect(_optionalChain([params, 'optionalAccess', _76 => _76.id])) ? true : "Select an instance.",
-      run: (_ctx, params) => _nullishCoalesce(controller.inspect(_optionalChain([params, 'optionalAccess', _77 => _77.id])), () => ( null))
+      enabled: (_ctx, params) => controller.inspect(_optionalChain([params, 'optionalAccess', _78 => _78.id])) ? true : "Select an instance.",
+      run: (_ctx, params) => _nullishCoalesce(controller.inspect(_optionalChain([params, 'optionalAccess', _79 => _79.id])), () => ( null))
     },
     ...hasVariantCommands(controller) ? variantCommands(controller, prefix, base) : []
   ];