@pixerate/editor-react 0.15.0 → 0.16.0

package/README.md

@@ -75,6 +75,8 @@ const editor = useEditor({ extensions: [Comments.configure({ author: me }), Trac
 
 `ReviewToolbar` steps through insertions, deletions, formatting and block changes and shows the current one's author and description (e.g. "Ada: Changed Paragraph to Heading 2"); hide it with `showDescription={false}` or restyle it with `descriptionClassName`. `useComments(editorOrStore)` and `useTrackChanges(editor)` expose the same state for custom UIs (each change has `type` and `description`).
 
+`FindReplaceBar` is a Word-style find bar for editors with the `FindReplace` extension (`useEditor({ richTextOptions: { findReplace: true } })`): it appears on Mod+F / Mod+H (or `editor.commands.openFindReplace()`), with find and replace fields, option toggles (match case, whole words, wildcards, regex, plus prefix/suffix/ignore punctuation/white space under "More options"), a "3 of 12" counter, previous/next, Replace and Replace all. Enter / Shift+Enter step, Enter in the replace field replaces, Mod+Enter replaces all, Escape closes. Pass `alwaysOpen` to keep it visible. `useFindReplace(editor)` exposes the state and commands for custom UIs.
+
 `useEditor({ fileImport: true, richClipboard: true })` imports dropped/pasted `.md`, `.html`, `.txt`, `.rtf` and `.docx` files (plus any adapter you register, e.g. PDF or zipped exports) at the drop position and copies lossless slices between editors. `useFileImport(editor)` returns `{ openFilePicker, importFiles, accept, isImporting, error }` for an import button. `usePromptEditor({ fileImport: true })` imports dropped files as plain text.
 
 `useAgentToolProvider(registry, provider)` registers an agent tool provider (see `ToolRegistry` in `@pixerate/editor/agent`) while the component is mounted. Memoize the provider:
@@ -92,6 +94,8 @@ useAgentToolProvider(registry, provider);
 | `@pixerate/editor-react/spreadsheet` | `SpreadsheetEditor`, `useSpreadsheetEditor`, `useSpreadsheetTableInteractions`, `FormulaHints`, `SpreadsheetContextMenu`, `SpreadsheetGroupRow` (also re-exported from the root entry) |
 | `@pixerate/editor-react/image-editor` | `ImageEditor`, `useImageEditor`: crop, rotate/flip, adjustments, annotations, depth masks, and `onInpaint` / `onRemoveBackground` AI hooks |
 | `@pixerate/editor-react/commands` | `CommandPalette`, `useCommandPalette` (`hotkey: "Mod+K"`), `useCommandShortcuts`, `useRegisterCommands` over a `CommandRegistry` from `@pixerate/editor/commands` (also re-exported from the root entry) |
+| `@pixerate/editor-react/persistence` | `useAutosave` (crash-recovery snapshots bound to a history / dirty flag, flushed on `pagehide`, with a recovery check on mount) and `<RecoveryPrompt>` (also re-exported from the root entry) |
+| `@pixerate/editor-react/generation` | `GenerationSettings` (controls generated from a model's capabilities, reference slots by role, plan adjustments), `useGenerationPlan`, `JobProgress`, `useJobProgress` over `@pixerate/editor/generation` (also re-exported from the root entry) |
 | `@pixerate/editor-react/canvas` | `useCanvasGraph`, `useCanvasLayout`, `useCanvasClipboard`, `useCanvasDocking`, `useCanvasShortcuts`, `useCanvasExplosion`, `useStreamingCanvas`, `AgentPresenceLayer`, plus the pure layout helpers from `@pixerate/editor/canvas` |
 
 ## Styling (Tailwind CSS required)

package/dist/canvas/index.cjs

@@ -20,125 +20,148 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/canvas/index.ts
 var canvas_exports = {};
 __export(canvas_exports, {
+  AUTO_LAYOUT_DATA_KEY: () => import_canvas15.AUTO_LAYOUT_DATA_KEY,
   AgentPresenceLayer: () => AgentPresenceLayer,
-  CONNECTION_LINE_TYPES: () => import_canvas11.CONNECTION_LINE_TYPES,
+  CHILD_LAYOUT_DATA_KEY: () => import_canvas15.CHILD_LAYOUT_DATA_KEY,
+  CONNECTION_LINE_TYPES: () => import_canvas12.CONNECTION_LINE_TYPES,
   CanvasGuidesLayer: () => CanvasGuidesLayer,
-  CanvasScenesStore: () => import_canvas11.CanvasScenesStore,
-  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas11.DEFAULT_ARRANGE_SHORTCUTS,
-  ManualClock: () => import_canvas13.ManualClock,
-  RESIZE_HANDLES: () => import_canvas10.RESIZE_HANDLES,
-  SHAPE_DATA_KEY: () => import_canvas12.SHAPE_DATA_KEY,
-  SHAPE_KINDS: () => import_canvas12.SHAPE_KINDS,
-  SHAPE_NODE_TYPE: () => import_canvas12.SHAPE_NODE_TYPE,
-  SHAPE_OPERATIONS: () => import_canvas12.SHAPE_OPERATIONS,
+  CanvasScenesStore: () => import_canvas12.CanvasScenesStore,
+  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas12.DEFAULT_ARRANGE_SHORTCUTS,
+  ManualClock: () => import_canvas14.ManualClock,
+  RESIZE_HANDLES: () => import_canvas11.RESIZE_HANDLES,
+  SHAPE_DATA_KEY: () => import_canvas13.SHAPE_DATA_KEY,
+  SHAPE_KINDS: () => import_canvas13.SHAPE_KINDS,
+  SHAPE_NODE_TYPE: () => import_canvas13.SHAPE_NODE_TYPE,
+  SHAPE_OPERATIONS: () => import_canvas13.SHAPE_OPERATIONS,
   ShapeNode: () => ShapeNode,
-  alignNodes: () => import_canvas11.alignNodes,
-  applyNodeUpdates: () => import_canvas11.applyNodeUpdates,
-  applyShapeCombination: () => import_canvas12.applyShapeCombination,
-  blendLayout: () => import_canvas13.blendLayout,
-  boundsOf: () => import_canvas13.boundsOf,
-  calculateDagreReflowDisplacement: () => import_canvas13.calculateDagreReflowDisplacement,
-  calculateDirectionalDisplacement: () => import_canvas13.calculateDirectionalDisplacement,
-  canCombineShapeNodes: () => import_canvas12.canCombineShapeNodes,
-  canvasHeight: () => import_canvas13.canvasHeight,
-  centerNodes: () => import_canvas13.centerNodes,
-  centre: () => import_canvas13.centre,
-  combineShapeNodes: () => import_canvas12.combineShapeNodes,
-  computeNodesBoundingBox: () => import_canvas13.computeNodesBoundingBox,
-  computeSnapGuides: () => import_canvas11.computeSnapGuides,
-  connectedOnly: () => import_canvas13.connectedOnly,
-  createBezierTrajectory: () => import_canvas13.createBezierTrajectory,
-  createCanvasScenesStore: () => import_canvas11.createCanvasScenesStore,
-  createFanOutTrajectory: () => import_canvas13.createFanOutTrajectory,
-  createGuideIndex: () => import_canvas11.createGuideIndex,
-  createNodeGuideIndex: () => import_canvas11.createNodeGuideIndex,
-  cubicPointAt: () => import_canvas10.cubicPointAt,
-  cubicsToPathData: () => import_canvas10.cubicsToPathData,
-  defaultEasing: () => import_canvas13.defaultEasing,
-  distributeNodes: () => import_canvas11.distributeNodes,
-  dividePolygons: () => import_canvas12.dividePolygons,
-  ensureLayout: () => import_canvas13.ensureLayout,
-  estimateCanvasHeight: () => import_canvas13.estimateCanvasHeight,
-  estimateNodeSize: () => import_canvas13.estimateNodeSize,
-  findConnectorSnap: () => import_canvas11.findConnectorSnap,
-  fitCubicRun: () => import_canvas10.fitCubicRun,
-  fitCubics: () => import_canvas10.fitCubics,
-  fitFreehandPath: () => import_canvas10.fitFreehandPath,
-  fitPathData: () => import_canvas10.fitPathData,
-  fitViewportToNodes: () => import_canvas11.fitViewportToNodes,
-  fitViewportToRect: () => import_canvas11.fitViewportToRect,
-  flattenSvgPath: () => import_canvas12.flattenSvgPath,
-  flowSide: () => import_canvas13.flowSide,
-  getAbsolutePosition: () => import_canvas11.getAbsolutePosition,
-  getCenteredNodePosition: () => import_canvas13.getCenteredNodePosition,
-  getLayoutedNodes: () => import_canvas13.getLayoutedNodes,
-  getNodeRect: () => import_canvas11.getNodeRect,
-  getNodeShape: () => import_canvas12.getNodeShape,
-  getNodeSize: () => import_canvas11.getNodeSize,
-  getResizingNodeRect: () => import_canvas10.getResizingNodeRect,
-  getShapeRenderData: () => import_canvas12.getShapeRenderData,
-  getShapeSvg: () => import_canvas12.getShapeSvg,
-  handlePoint: () => import_canvas11.handlePoint,
-  inferResizeHandle: () => import_canvas10.inferResizeHandle,
-  intersectPolygons: () => import_canvas12.intersectPolygons,
-  invertNodeUpdates: () => import_canvas11.invertNodeUpdates,
-  isEventFromTextInput: () => import_canvas13.isEventFromTextInput,
-  isLocked: () => import_canvas11.isLocked,
-  isMeasureModifierHeld: () => import_canvas10.isMeasureModifierHeld,
-  isShapeDescription: () => import_canvas12.isShapeDescription,
-  isShapeNode: () => import_canvas12.isShapeNode,
-  isStraightCubic: () => import_canvas10.isStraightCubic,
-  isValidCanvasNode: () => import_canvas13.isValidCanvasNode,
-  isValidUrl: () => import_canvas13.isValidUrl,
-  layoutBounds: () => import_canvas13.layoutBounds,
-  linearPositionTrajectory: () => import_canvas13.linearPositionTrajectory,
-  linearTrajectory: () => import_canvas13.linearTrajectory,
-  lockNodes: () => import_canvas11.lockNodes,
-  matchArrangeShortcut: () => import_canvas11.matchArrangeShortcut,
-  matchSize: () => import_canvas11.matchSize,
-  measureBetween: () => import_canvas10.measureBetween,
-  measureLabel: () => import_canvas10.measureLabel,
-  measureSelection: () => import_canvas10.measureSelection,
-  measureToLine: () => import_canvas10.measureToLine,
-  multiPolygonArea: () => import_canvas12.multiPolygonArea,
-  multiPolygonBounds: () => import_canvas12.multiPolygonBounds,
-  nearestHandlePositions: () => import_canvas11.nearestHandlePositions,
-  oppositePosition: () => import_canvas11.oppositePosition,
-  overlaps: () => import_canvas13.overlaps,
-  parseCanvasClipboardData: () => import_canvas13.parseCanvasClipboardData,
-  parseCanvasScenes: () => import_canvas11.parseCanvasScenes,
-  parseSvgPath: () => import_canvas12.parseSvgPath,
-  placeBeside: () => import_canvas13.placeBeside,
-  pointInMultiPolygon: () => import_canvas12.pointInMultiPolygon,
-  pointInRings: () => import_canvas12.pointInRings,
-  polygonArea: () => import_canvas12.polygonArea,
-  polygonBoolean: () => import_canvas12.polygonBoolean,
-  polygonToSvgPath: () => import_canvas12.polygonToSvgPath,
-  positionToSide: () => import_canvas11.positionToSide,
-  readStyleSize: () => import_canvas11.readStyleSize,
-  realClock: () => import_canvas13.realClock,
-  remapPastedNodes: () => import_canvas13.remapPastedNodes,
-  reorderNodes: () => import_canvas11.reorderNodes,
-  repositionNodesTo: () => import_canvas13.repositionNodesTo,
-  resizeHandleAxes: () => import_canvas10.resizeHandleAxes,
-  revertShapeCombination: () => import_canvas12.revertShapeCombination,
-  ringSignedArea: () => import_canvas12.ringSignedArea,
-  runMultiNodeTransition: () => import_canvas13.runMultiNodeTransition,
-  serializeCanvasNodes: () => import_canvas13.serializeCanvasNodes,
-  shapeNodeToPolygon: () => import_canvas12.shapeNodeToPolygon,
-  shapeToPolygon: () => import_canvas12.shapeToPolygon,
-  sideToPosition: () => import_canvas11.sideToPosition,
-  simplifyRing: () => import_canvas12.simplifyRing,
-  snapNodeDrag: () => import_canvas11.snapNodeDrag,
-  snapNodeResize: () => import_canvas10.snapNodeResize,
-  snapResize: () => import_canvas10.snapResize,
-  snapToGrid: () => import_canvas10.snapToGrid,
-  subtractPolygons: () => import_canvas12.subtractPolygons,
-  toggleLockNodes: () => import_canvas11.toggleLockNodes,
-  unionPolygons: () => import_canvas12.unionPolygons,
-  unlockNodes: () => import_canvas11.unlockNodes,
+  alignNodes: () => import_canvas12.alignNodes,
+  applyConstraints: () => import_canvas15.applyConstraints,
+  applyNodeUpdates: () => import_canvas12.applyNodeUpdates,
+  applyShapeCombination: () => import_canvas13.applyShapeCombination,
+  blendLayout: () => import_canvas14.blendLayout,
+  boundsOf: () => import_canvas14.boundsOf,
+  calculateDagreReflowDisplacement: () => import_canvas14.calculateDagreReflowDisplacement,
+  calculateDirectionalDisplacement: () => import_canvas14.calculateDirectionalDisplacement,
+  canCombineShapeNodes: () => import_canvas13.canCombineShapeNodes,
+  canvasHeight: () => import_canvas14.canvasHeight,
+  centerNodes: () => import_canvas14.centerNodes,
+  centre: () => import_canvas14.centre,
+  clampLayoutSize: () => import_canvas15.clampLayoutSize,
+  combineShapeNodes: () => import_canvas13.combineShapeNodes,
+  computeNodesBoundingBox: () => import_canvas14.computeNodesBoundingBox,
+  computeSnapGuides: () => import_canvas12.computeSnapGuides,
+  connectedOnly: () => import_canvas14.connectedOnly,
+  createBezierTrajectory: () => import_canvas14.createBezierTrajectory,
+  createCanvasAutoLayoutController: () => import_canvas15.createCanvasAutoLayoutController,
+  createCanvasScenesStore: () => import_canvas12.createCanvasScenesStore,
+  createFanOutTrajectory: () => import_canvas14.createFanOutTrajectory,
+  createGuideIndex: () => import_canvas12.createGuideIndex,
+  createNodeGuideIndex: () => import_canvas12.createNodeGuideIndex,
+  cubicPointAt: () => import_canvas11.cubicPointAt,
+  cubicsToPathData: () => import_canvas11.cubicsToPathData,
+  defaultEasing: () => import_canvas14.defaultEasing,
+  distributeNodes: () => import_canvas12.distributeNodes,
+  dividePolygons: () => import_canvas13.dividePolygons,
+  ensureLayout: () => import_canvas14.ensureLayout,
+  estimateCanvasHeight: () => import_canvas14.estimateCanvasHeight,
+  estimateNodeSize: () => import_canvas14.estimateNodeSize,
+  findConnectorSnap: () => import_canvas12.findConnectorSnap,
+  fitCubicRun: () => import_canvas11.fitCubicRun,
+  fitCubics: () => import_canvas11.fitCubics,
+  fitFreehandPath: () => import_canvas11.fitFreehandPath,
+  fitPathData: () => import_canvas11.fitPathData,
+  fitViewportToNodes: () => import_canvas12.fitViewportToNodes,
+  fitViewportToRect: () => import_canvas12.fitViewportToRect,
+  flattenSvgPath: () => import_canvas13.flattenSvgPath,
+  flowSide: () => import_canvas14.flowSide,
+  getAbsolutePosition: () => import_canvas12.getAbsolutePosition,
+  getAutoLayout: () => import_canvas15.getAutoLayout,
+  getAutoLayoutGrid: () => import_canvas15.getAutoLayoutGrid,
+  getAutoLayoutInsertTarget: () => import_canvas15.getAutoLayoutInsertTarget,
+  getCenteredNodePosition: () => import_canvas14.getCenteredNodePosition,
+  getChildLayout: () => import_canvas15.getChildLayout,
+  getFlowChildren: () => import_canvas15.getFlowChildren,
+  getLayoutParent: () => import_canvas15.getLayoutParent,
+  getLayoutSizing: () => import_canvas15.getLayoutSizing,
+  getLayoutedNodes: () => import_canvas14.getLayoutedNodes,
+  getNodeRect: () => import_canvas12.getNodeRect,
+  getNodeShape: () => import_canvas13.getNodeShape,
+  getNodeSize: () => import_canvas12.getNodeSize,
+  getResizingNodeRect: () => import_canvas11.getResizingNodeRect,
+  getShapeRenderData: () => import_canvas13.getShapeRenderData,
+  getShapeSvg: () => import_canvas13.getShapeSvg,
+  handlePoint: () => import_canvas12.handlePoint,
+  inferResizeHandle: () => import_canvas11.inferResizeHandle,
+  intersectPolygons: () => import_canvas13.intersectPolygons,
+  invertNodeUpdates: () => import_canvas12.invertNodeUpdates,
+  isAutoLayoutFrame: () => import_canvas15.isAutoLayoutFrame,
+  isEventFromTextInput: () => import_canvas14.isEventFromTextInput,
+  isLocked: () => import_canvas12.isLocked,
+  isMeasureModifierHeld: () => import_canvas11.isMeasureModifierHeld,
+  isShapeDescription: () => import_canvas13.isShapeDescription,
+  isShapeNode: () => import_canvas13.isShapeNode,
+  isStraightCubic: () => import_canvas11.isStraightCubic,
+  isValidCanvasNode: () => import_canvas14.isValidCanvasNode,
+  isValidUrl: () => import_canvas14.isValidUrl,
+  layoutAll: () => import_canvas15.layoutAll,
+  layoutBounds: () => import_canvas14.layoutBounds,
+  layoutFrame: () => import_canvas15.layoutFrame,
+  layoutUp: () => import_canvas15.layoutUp,
+  layoutUpMany: () => import_canvas15.layoutUpMany,
+  linearPositionTrajectory: () => import_canvas14.linearPositionTrajectory,
+  linearTrajectory: () => import_canvas14.linearTrajectory,
+  lockNodes: () => import_canvas12.lockNodes,
+  makeSizingCoherent: () => import_canvas15.makeSizingCoherent,
+  matchArrangeShortcut: () => import_canvas12.matchArrangeShortcut,
+  matchSize: () => import_canvas12.matchSize,
+  measureBetween: () => import_canvas11.measureBetween,
+  measureLabel: () => import_canvas11.measureLabel,
+  measureSelection: () => import_canvas11.measureSelection,
+  measureToLine: () => import_canvas11.measureToLine,
+  mergeNodeUpdates: () => import_canvas15.mergeNodeUpdates,
+  moveLayoutChild: () => import_canvas15.moveLayoutChild,
+  multiPolygonArea: () => import_canvas13.multiPolygonArea,
+  multiPolygonBounds: () => import_canvas13.multiPolygonBounds,
+  nearestHandlePositions: () => import_canvas12.nearestHandlePositions,
+  oppositePosition: () => import_canvas12.oppositePosition,
+  overlaps: () => import_canvas14.overlaps,
+  parseCanvasClipboardData: () => import_canvas14.parseCanvasClipboardData,
+  parseCanvasScenes: () => import_canvas12.parseCanvasScenes,
+  parseSvgPath: () => import_canvas13.parseSvgPath,
+  placeBeside: () => import_canvas14.placeBeside,
+  pointInMultiPolygon: () => import_canvas13.pointInMultiPolygon,
+  pointInRings: () => import_canvas13.pointInRings,
+  polygonArea: () => import_canvas13.polygonArea,
+  polygonBoolean: () => import_canvas13.polygonBoolean,
+  polygonToSvgPath: () => import_canvas13.polygonToSvgPath,
+  positionToSide: () => import_canvas12.positionToSide,
+  readStyleSize: () => import_canvas12.readStyleSize,
+  realClock: () => import_canvas14.realClock,
+  relayoutUpdates: () => import_canvas15.relayoutUpdates,
+  remapPastedNodes: () => import_canvas14.remapPastedNodes,
+  reorderNodes: () => import_canvas12.reorderNodes,
+  repositionNodesTo: () => import_canvas14.repositionNodesTo,
+  resizeHandleAxes: () => import_canvas11.resizeHandleAxes,
+  resolvePadding: () => import_canvas15.resolvePadding,
+  revertShapeCombination: () => import_canvas13.revertShapeCombination,
+  ringSignedArea: () => import_canvas13.ringSignedArea,
+  runMultiNodeTransition: () => import_canvas14.runMultiNodeTransition,
+  serializeCanvasNodes: () => import_canvas14.serializeCanvasNodes,
+  shapeNodeToPolygon: () => import_canvas13.shapeNodeToPolygon,
+  shapeToPolygon: () => import_canvas13.shapeToPolygon,
+  sideToPosition: () => import_canvas12.sideToPosition,
+  simplifyRing: () => import_canvas13.simplifyRing,
+  snapNodeDrag: () => import_canvas12.snapNodeDrag,
+  snapNodeResize: () => import_canvas11.snapNodeResize,
+  snapResize: () => import_canvas11.snapResize,
+  snapToGrid: () => import_canvas11.snapToGrid,
+  subtractPolygons: () => import_canvas13.subtractPolygons,
+  toggleLockNodes: () => import_canvas12.toggleLockNodes,
+  unionPolygons: () => import_canvas13.unionPolygons,
+  unlockNodes: () => import_canvas12.unlockNodes,
   useCanvasArrange: () => useCanvasArrange,
   useCanvasArrangeShortcuts: () => useCanvasArrangeShortcuts,
+  useCanvasAutoLayout: () => useCanvasAutoLayout,
   useCanvasClipboard: () => useCanvasClipboard,
   useCanvasDocking: () => useCanvasDocking,
   useCanvasExplosion: () => useCanvasExplosion,
@@ -148,8 +171,8 @@ __export(canvas_exports, {
   useCanvasScenes: () => useCanvasScenes,
   useCanvasShortcuts: () => useCanvasShortcuts,
   useStreamingCanvas: () => useStreamingCanvas,
-  withStyleSize: () => import_canvas11.withStyleSize,
-  xorPolygons: () => import_canvas12.xorPolygons
+  withStyleSize: () => import_canvas12.withStyleSize,
+  xorPolygons: () => import_canvas13.xorPolygons
 });
 module.exports = __toCommonJS(canvas_exports);
 
@@ -924,6 +947,9 @@ function useCanvasArrange(options) {
       get rectOptions() {
         return optionsRef.current.rectOptions;
       },
+      get autoLayout() {
+        return optionsRef.current.autoLayout;
+      },
       onGuidesChange: setGuides
     }),
     []
@@ -1159,8 +1185,8 @@ function useCanvasMeasure(options) {
 }
 
 // src/canvas/index.ts
-var import_canvas10 = require("@pixerate/editor/canvas");
 var import_canvas11 = require("@pixerate/editor/canvas");
+var import_canvas12 = require("@pixerate/editor/canvas");
 
 // src/canvas/ShapeNode.tsx
 var import_canvas9 = require("@pixerate/editor/canvas");
@@ -1208,11 +1234,65 @@ function ShapeNode({ data, width, height, selected, className = "", children })
 }
 
 // src/canvas/index.ts
-var import_canvas12 = require("@pixerate/editor/canvas");
 var import_canvas13 = require("@pixerate/editor/canvas");
+var import_canvas14 = require("@pixerate/editor/canvas");
+var import_canvas15 = require("@pixerate/editor/canvas");
+
+// src/canvas/useCanvasAutoLayout.ts
+var import_react11 = require("react");
+var import_canvas10 = require("@pixerate/editor/canvas");
+function useCanvasAutoLayout(options) {
+  const [guides, setGuides] = (0, import_react11.useState)([]);
+  const nodesRef = (0, import_react11.useRef)(options.nodes);
+  nodesRef.current = options.nodes;
+  const optionsRef = (0, import_react11.useRef)(options);
+  optionsRef.current = options;
+  const controller = (0, import_react11.useMemo)(
+    () => (0, import_canvas10.createCanvasAutoLayoutController)({
+      getNodes: () => nodesRef.current,
+      setNodes: (next) => {
+        nodesRef.current = next;
+        optionsRef.current.setNodes(next);
+      },
+      get history() {
+        return optionsRef.current.history;
+      },
+      get enabled() {
+        return optionsRef.current.enabled;
+      },
+      get dragReorder() {
+        return optionsRef.current.dragReorder;
+      },
+      get measure() {
+        return optionsRef.current.measure;
+      },
+      get rectOptions() {
+        return optionsRef.current.rectOptions;
+      },
+      onGuidesChange: setGuides
+    }),
+    []
+  );
+  (0, import_react11.useLayoutEffect)(() => {
+    if (controller.hasPending) controller.flush();
+  }, [options.nodes, controller]);
+  return (0, import_react11.useMemo)(
+    () => ({
+      ...controller,
+      /** Drop marker of the active reorder drag (flow coordinates). */
+      guides,
+      get hasPending() {
+        return controller.hasPending;
+      }
+    }),
+    [controller, guides]
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AUTO_LAYOUT_DATA_KEY,
   AgentPresenceLayer,
+  CHILD_LAYOUT_DATA_KEY,
   CONNECTION_LINE_TYPES,
   CanvasGuidesLayer,
   CanvasScenesStore,
@@ -1225,6 +1305,7 @@ var import_canvas13 = require("@pixerate/editor/canvas");
   SHAPE_OPERATIONS,
   ShapeNode,
   alignNodes,
+  applyConstraints,
   applyNodeUpdates,
   applyShapeCombination,
   blendLayout,
@@ -1235,11 +1316,13 @@ var import_canvas13 = require("@pixerate/editor/canvas");
   canvasHeight,
   centerNodes,
   centre,
+  clampLayoutSize,
   combineShapeNodes,
   computeNodesBoundingBox,
   computeSnapGuides,
   connectedOnly,
   createBezierTrajectory,
+  createCanvasAutoLayoutController,
   createCanvasScenesStore,
   createFanOutTrajectory,
   createGuideIndex,
@@ -1262,7 +1345,14 @@ var import_canvas13 = require("@pixerate/editor/canvas");
   flattenSvgPath,
   flowSide,
   getAbsolutePosition,
+  getAutoLayout,
+  getAutoLayoutGrid,
+  getAutoLayoutInsertTarget,
   getCenteredNodePosition,
+  getChildLayout,
+  getFlowChildren,
+  getLayoutParent,
+  getLayoutSizing,
   getLayoutedNodes,
   getNodeRect,
   getNodeShape,
@@ -1274,6 +1364,7 @@ var import_canvas13 = require("@pixerate/editor/canvas");
   inferResizeHandle,
   intersectPolygons,
   invertNodeUpdates,
+  isAutoLayoutFrame,
   isEventFromTextInput,
   isLocked,
   isMeasureModifierHeld,
@@ -1282,16 +1373,23 @@ var import_canvas13 = require("@pixerate/editor/canvas");
   isStraightCubic,
   isValidCanvasNode,
   isValidUrl,
+  layoutAll,
   layoutBounds,
+  layoutFrame,
+  layoutUp,
+  layoutUpMany,
   linearPositionTrajectory,
   linearTrajectory,
   lockNodes,
+  makeSizingCoherent,
   matchArrangeShortcut,
   matchSize,
   measureBetween,
   measureLabel,
   measureSelection,
   measureToLine,
+  mergeNodeUpdates,
+  moveLayoutChild,
   multiPolygonArea,
   multiPolygonBounds,
   nearestHandlePositions,
@@ -1309,10 +1407,12 @@ var import_canvas13 = require("@pixerate/editor/canvas");
   positionToSide,
   readStyleSize,
   realClock,
+  relayoutUpdates,
   remapPastedNodes,
   reorderNodes,
   repositionNodesTo,
   resizeHandleAxes,
+  resolvePadding,
   revertShapeCombination,
   ringSignedArea,
   runMultiNodeTransition,
@@ -1331,6 +1431,7 @@ var import_canvas13 = require("@pixerate/editor/canvas");
   unlockNodes,
   useCanvasArrange,
   useCanvasArrangeShortcuts,
+  useCanvasAutoLayout,
   useCanvasClipboard,
   useCanvasDocking,
   useCanvasExplosion,