@woven-canvas/core 0.1.0

package/build/index.cjs

@@ -0,0 +1,4109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Aabb: () => Aabb,
+  Asset: () => Asset,
+  Block: () => Block,
+  BlockDef: () => BlockDef2,
+  Camera: () => Camera,
+  CanvasComponentDef: () => import_canvas_store34.CanvasComponentDef,
+  CanvasSingletonDef: () => import_canvas_store34.CanvasSingletonDef,
+  Color: () => Color,
+  CommandMarker: () => CommandMarker,
+  ComponentDef: () => import_core49.ComponentDef,
+  Connector: () => Connector,
+  Controls: () => Controls,
+  ControlsOptions: () => ControlsOptions,
+  CorePlugin: () => CorePlugin,
+  Cursor: () => Cursor,
+  CursorDef: () => CursorDef,
+  Edited: () => Edited,
+  Editor: () => Editor,
+  EditorStateDef: () => EditorStateDef,
+  EventType: () => import_core49.EventType,
+  FontFamily: () => FontFamily,
+  FontLoader: () => FontLoader,
+  Frame: () => Frame,
+  Grid: () => Grid,
+  GridOptions: () => GridOptions,
+  Held: () => Held,
+  HitGeometry: () => HitGeometry,
+  Hovered: () => Hovered,
+  Image: () => Image,
+  Intersect: () => Intersect,
+  Key: () => Key,
+  Keybind: () => Keybind,
+  Keyboard: () => Keyboard,
+  MAX_HIT_ARCS: () => MAX_HIT_ARCS,
+  MAX_HIT_CAPSULES: () => MAX_HIT_CAPSULES,
+  MainThreadSystem: () => import_core49.MainThreadSystem,
+  Mouse: () => Mouse,
+  Opacity: () => Opacity,
+  Pointer: () => Pointer,
+  PointerButton: () => PointerButton,
+  PointerType: () => PointerType,
+  RankBounds: () => RankBounds,
+  Redo: () => Redo,
+  SINGLETON_ENTITY_ID: () => import_core49.SINGLETON_ENTITY_ID,
+  STRATUM_ORDER: () => STRATUM_ORDER,
+  ScaleWithZoom: () => ScaleWithZoom,
+  ScaleWithZoomState: () => ScaleWithZoomState,
+  Screen: () => Screen,
+  Shape: () => Shape,
+  Stratum: () => Stratum,
+  StrokeKind: () => StrokeKind,
+  Synced: () => import_canvas_store34.Synced,
+  Text: () => Text,
+  TextAlignment: () => TextAlignment,
+  Undo: () => Undo,
+  UploadState: () => UploadState,
+  User: () => User,
+  UserData: () => UserData,
+  VerticalAlign: () => VerticalAlign,
+  VerticalAlignment: () => VerticalAlignment,
+  addComponent: () => import_core49.addComponent,
+  canBlockEdit: () => canBlockEdit,
+  clearPointerTrackingState: () => clearPointerTrackingState,
+  createEntity: () => import_core49.createEntity,
+  defineCanvasComponent: () => import_canvas_store34.defineCanvasComponent,
+  defineCanvasSingleton: () => import_canvas_store34.defineCanvasSingleton,
+  defineCommand: () => defineCommand,
+  defineEditorState: () => defineEditorState,
+  defineEditorSystem: () => defineEditorSystem,
+  defineQuery: () => import_core49.defineQuery,
+  defineSystem: () => import_core49.defineSystem,
+  field: () => import_core49.field,
+  getBackrefs: () => import_core49.getBackrefs,
+  getBlockDef: () => getBlockDef,
+  getFrameInput: () => getFrameInput,
+  getKeyboardInput: () => getKeyboardInput,
+  getMouseInput: () => getMouseInput,
+  getPluginResources: () => getPluginResources,
+  getPointerInput: () => getPointerInput,
+  getResources: () => import_core49.getResources,
+  getTopmostBlockAtPoint: () => getTopmostBlockAtPoint,
+  hasComponent: () => import_core49.hasComponent,
+  intersectAabb: () => intersectAabb,
+  intersectCapsule: () => intersectCapsule,
+  intersectPoint: () => intersectPoint,
+  isAlive: () => import_core49.isAlive,
+  isHeldByRemote: () => isHeldByRemote,
+  on: () => on,
+  parsePlugin: () => parsePlugin,
+  removeComponent: () => import_core49.removeComponent,
+  removeEntity: () => import_core49.removeEntity,
+  runMachine: () => runMachine
+});
+module.exports = __toCommonJS(index_exports);
+var import_canvas_store34 = require("@woven-ecs/canvas-store");
+var import_core49 = require("@woven-ecs/core");
+
+// src/CorePlugin.ts
+var import_canvas_store31 = require("@woven-ecs/canvas-store");
+var import_core46 = require("@woven-ecs/core");
+
+// src/components/index.ts
+var components_exports = {};
+__export(components_exports, {
+  Aabb: () => Aabb,
+  Asset: () => Asset,
+  Block: () => Block,
+  Color: () => Color,
+  Connector: () => Connector,
+  Edited: () => Edited,
+  Held: () => Held,
+  HitGeometry: () => HitGeometry,
+  Hovered: () => Hovered,
+  Image: () => Image,
+  MAX_HIT_ARCS: () => MAX_HIT_ARCS,
+  MAX_HIT_CAPSULES: () => MAX_HIT_CAPSULES,
+  Opacity: () => Opacity,
+  Pointer: () => Pointer,
+  PointerButton: () => PointerButton,
+  PointerType: () => PointerType,
+  ScaleWithZoom: () => ScaleWithZoom,
+  Shape: () => Shape,
+  StrokeKind: () => StrokeKind,
+  Text: () => Text,
+  UploadState: () => UploadState,
+  User: () => User,
+  VerticalAlign: () => VerticalAlign,
+  addPointerSample: () => addPointerSample
+});
+
+// src/components/Aabb.ts
+var import_math2 = require("@woven-canvas/math");
+var import_canvas_store2 = require("@woven-ecs/canvas-store");
+var import_core2 = require("@woven-ecs/core");
+
+// src/components/Block.ts
+var import_math = require("@woven-canvas/math");
+var import_canvas_store = require("@woven-ecs/canvas-store");
+var import_core = require("@woven-ecs/core");
+var _aabbCorners = [
+  [0, 0],
+  [0, 0],
+  [0, 0],
+  [0, 0]
+];
+var _blockCorners = [
+  [0, 0],
+  [0, 0],
+  [0, 0],
+  [0, 0]
+];
+var _blockAxes = [
+  [0, 0],
+  [0, 0]
+];
+var BlockSchema = {
+  /** Element tag name (e.g., "div", "img") */
+  tag: import_core.field.string().max(36).default("div"),
+  /** Position as [left, top] */
+  position: import_core.field.tuple(import_core.field.float64(), 2).default([0, 0]),
+  /** Size as [width, height] */
+  size: import_core.field.tuple(import_core.field.float64(), 2).default([100, 100]),
+  /** Rotation around center in radians */
+  rotateZ: import_core.field.float64().default(0),
+  /** Flip state as [flipX, flipY] */
+  flip: import_core.field.tuple(import_core.field.boolean(), 2).default([false, false]),
+  /** Z-order rank (LexoRank string) */
+  rank: import_core.field.string().max(36).default("")
+};
+var BlockDef = class extends import_canvas_store.CanvasComponentDef {
+  constructor() {
+    super({ name: "block", sync: "document" }, BlockSchema);
+  }
+  /**
+   * Get the center point of a block.
+   * @param out - Optional output vector to write to (avoids allocation)
+   */
+  getCenter(ctx, entityId, out) {
+    const { position, size } = this.read(ctx, entityId);
+    const result = out ?? [0, 0];
+    import_math.Rect.getCenter(position, size, result);
+    return result;
+  }
+  /**
+   * Set the center point of a block (adjusts position accordingly).
+   */
+  setCenter(ctx, entityId, center) {
+    const block = this.write(ctx, entityId);
+    import_math.Rect.setCenter(block.position, block.size, center);
+  }
+  /**
+   * Get the four corner points of a block (accounting for rotation).
+   * Returns corners in order: top-left, top-right, bottom-right, bottom-left.
+   * @param out - Optional output array to write to (avoids allocation)
+   */
+  getCorners(ctx, entityId, out) {
+    const { position, size, rotateZ } = this.read(ctx, entityId);
+    const result = out ?? [
+      [0, 0],
+      [0, 0],
+      [0, 0],
+      [0, 0]
+    ];
+    import_math.Rect.getCorners(position, size, rotateZ, result);
+    return result;
+  }
+  /**
+   * Check if a point intersects a block (accounting for rotation).
+   */
+  containsPoint(ctx, entityId, point) {
+    const { position, size, rotateZ } = this.read(ctx, entityId);
+    return import_math.Rect.containsPoint(position, size, rotateZ, point);
+  }
+  /**
+   * Move a block by a delta offset.
+   */
+  translate(ctx, entityId, delta) {
+    const block = this.write(ctx, entityId);
+    import_math.Rect.translate(block.position, delta);
+  }
+  /**
+   * Set the position of a block.
+   */
+  setPosition(ctx, entityId, position) {
+    const block = this.write(ctx, entityId);
+    import_math.Vec2.copy(block.position, position);
+  }
+  /**
+   * Set the size of a block.
+   */
+  setSize(ctx, entityId, size) {
+    const block = this.write(ctx, entityId);
+    import_math.Vec2.copy(block.size, size);
+  }
+  /**
+   * Rotate a block by a delta angle (in radians).
+   */
+  rotateBy(ctx, entityId, deltaAngle) {
+    const block = this.write(ctx, entityId);
+    block.rotateZ += deltaAngle;
+  }
+  /**
+   * Rotate a block around a pivot point.
+   */
+  rotateAround(ctx, entityId, pivot, angle) {
+    const block = this.write(ctx, entityId);
+    block.rotateZ = import_math.Rect.rotateAround(block.position, block.size, block.rotateZ, pivot, angle);
+  }
+  /**
+   * Scale a block uniformly around its center.
+   */
+  scaleBy(ctx, entityId, scaleFactor) {
+    const block = this.write(ctx, entityId);
+    import_math.Rect.scaleBy(block.position, block.size, scaleFactor);
+  }
+  /**
+   * Scale a block around a pivot point.
+   */
+  scaleAround(ctx, entityId, pivot, scaleFactor) {
+    const block = this.write(ctx, entityId);
+    import_math.Rect.scaleAround(block.position, block.size, pivot, scaleFactor);
+  }
+  /**
+   * Check if an AABB intersects with this block using Separating Axis Theorem.
+   * This handles all intersection cases including narrow AABBs that pass through
+   * the middle of a rotated block without touching any corners.
+   * Optimized to avoid allocations for hot path usage.
+   */
+  intersectsAabb(ctx, entityId, aabb) {
+    const { position, size, rotateZ } = this.read(ctx, entityId);
+    return import_math.Rect.intersectsAabb(position, size, rotateZ, aabb, _blockCorners, _aabbCorners, _blockAxes);
+  }
+  worldToUv(ctx, entityId, worldPos) {
+    const { position, size, rotateZ, flip } = this.read(ctx, entityId);
+    const uv = import_math.Rect.worldToUv(position, size, rotateZ, worldPos);
+    if (flip[0]) uv[0] = 1 - uv[0];
+    if (flip[1]) uv[1] = 1 - uv[1];
+    return uv;
+  }
+  uvToWorld(ctx, entityId, uv) {
+    const { position, size, rotateZ, flip } = this.read(ctx, entityId);
+    const flippedUv = [flip[0] ? 1 - uv[0] : uv[0], flip[1] ? 1 - uv[1] : uv[1]];
+    return import_math.Rect.uvToWorld(position, size, rotateZ, flippedUv);
+  }
+  /**
+   * Get the UV-to-world transformation matrix for a block.
+   * More efficient than multiple uvToWorld() calls since sin/cos is computed once.
+   * Use with Mat2.transformPoint() to transform UV coordinates to world.
+   * Note: This matrix does NOT account for flip - use uvToWorld() for flipped blocks.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param out - Output matrix to write to [a, b, c, d, tx, ty]
+   */
+  getUvToWorldMatrix(ctx, entityId, out) {
+    const { position, size, rotateZ, flip } = this.read(ctx, entityId);
+    import_math.Rect.getUvToWorldMatrix(position, size, rotateZ, out);
+    if (flip[0]) {
+      out[0] = -out[0];
+      out[2] = -out[2];
+      out[4] += size[0] * Math.cos(rotateZ);
+      out[5] += size[0] * Math.sin(rotateZ);
+    }
+    if (flip[1]) {
+      out[1] = -out[1];
+      out[3] = -out[3];
+      out[4] -= size[1] * Math.sin(rotateZ);
+      out[5] += size[1] * Math.cos(rotateZ);
+    }
+  }
+};
+var Block = new BlockDef();
+
+// src/components/Aabb.ts
+var LEFT = 0;
+var TOP = 1;
+var RIGHT = 2;
+var BOTTOM = 3;
+var AabbSchema = {
+  /** Bounds as [left, top, right, bottom] */
+  value: import_core2.field.tuple(import_core2.field.float32(), 4).default([0, 0, 0, 0])
+};
+var AabbDef = class extends import_canvas_store2.CanvasComponentDef {
+  constructor() {
+    super({ name: "aabb" }, AabbSchema);
+  }
+  /**
+   * Check if a point is contained within an entity's AABB.
+   */
+  containsPoint(ctx, entityId, point, inclusive = true) {
+    const { value } = this.read(ctx, entityId);
+    return import_math2.Aabb.containsPoint(value, point, inclusive);
+  }
+  /**
+   * Expand AABB to include a point.
+   */
+  expandByPoint(ctx, entityId, point) {
+    const { value } = this.write(ctx, entityId);
+    import_math2.Aabb.expand(value, point);
+  }
+  /**
+   * Expand AABB to include another entity's block.
+   */
+  expandByBlock(ctx, entityId, blockEntityId) {
+    const corners = Block.getCorners(ctx, blockEntityId);
+    const { value } = this.write(ctx, entityId);
+    for (const corner of corners) {
+      import_math2.Aabb.expand(value, corner);
+    }
+  }
+  /**
+   * Expand AABB to include another AABB.
+   */
+  expandByAabb(ctx, entityId, other) {
+    const { value } = this.write(ctx, entityId);
+    import_math2.Aabb.union(value, other);
+  }
+  /**
+   * Copy bounds from another entity's AABB.
+   */
+  copyFrom(ctx, entityId, otherEntityId) {
+    const { value: src } = this.read(ctx, otherEntityId);
+    const { value: dst } = this.write(ctx, entityId);
+    import_math2.Aabb.copy(dst, src);
+  }
+  /**
+   * Set AABB from an array of points.
+   */
+  setByPoints(ctx, entityId, points) {
+    if (points.length === 0) return;
+    const { value } = this.write(ctx, entityId);
+    import_math2.Aabb.setFromPoints(value, points);
+  }
+  /**
+   * Get the center point of an entity's AABB.
+   */
+  getCenter(ctx, entityId) {
+    const { value } = this.read(ctx, entityId);
+    return import_math2.Aabb.center(value);
+  }
+  /**
+   * Get the width of an entity's AABB.
+   */
+  getWidth(ctx, entityId) {
+    const { value } = this.read(ctx, entityId);
+    return import_math2.Aabb.width(value);
+  }
+  /**
+   * Get the height of an entity's AABB.
+   */
+  getHeight(ctx, entityId) {
+    const { value } = this.read(ctx, entityId);
+    return import_math2.Aabb.height(value);
+  }
+  /**
+   * Get the distance from AABB to a point.
+   */
+  distanceToPoint(ctx, entityId, point) {
+    const { value } = this.read(ctx, entityId);
+    return import_math2.Aabb.distanceToPoint(value, point);
+  }
+  /**
+   * Check if two entity AABBs intersect.
+   */
+  intersectsEntity(ctx, entityIdA, entityIdB) {
+    const { value: a } = this.read(ctx, entityIdA);
+    const { value: b } = this.read(ctx, entityIdB);
+    return import_math2.Aabb.intersects(a, b);
+  }
+  /**
+   * Check if entity A's AABB completely surrounds entity B's AABB.
+   */
+  surroundsEntity(ctx, entityIdA, entityIdB) {
+    const { value: a } = this.read(ctx, entityIdA);
+    const { value: b } = this.read(ctx, entityIdB);
+    return import_math2.Aabb.contains(a, b);
+  }
+  /**
+   * Get the four corner points of an entity's AABB.
+   * Returns corners in order: top-left, top-right, bottom-right, bottom-left.
+   * @param out - Optional output array to write to (avoids allocation)
+   */
+  getCorners(ctx, entityId, out) {
+    const { value } = this.read(ctx, entityId);
+    const result = out ?? [
+      [0, 0],
+      [0, 0],
+      [0, 0],
+      [0, 0]
+    ];
+    result[0][0] = value[LEFT];
+    result[0][1] = value[TOP];
+    result[1][0] = value[RIGHT];
+    result[1][1] = value[TOP];
+    result[2][0] = value[RIGHT];
+    result[2][1] = value[BOTTOM];
+    result[3][0] = value[LEFT];
+    result[3][1] = value[BOTTOM];
+    return result;
+  }
+  /**
+   * Apply padding to all sides of the AABB.
+   */
+  applyPadding(ctx, entityId, padding) {
+    const { value } = this.write(ctx, entityId);
+    import_math2.Aabb.pad(value, padding);
+  }
+};
+var Aabb = new AabbDef();
+
+// src/components/Asset.ts
+var import_canvas_store3 = require("@woven-ecs/canvas-store");
+var import_core3 = require("@woven-ecs/core");
+var UploadState = {
+  /** Asset queued for upload, not yet started */
+  Pending: "pending",
+  /** Upload in progress */
+  Uploading: "uploading",
+  /** Upload completed successfully */
+  Complete: "complete",
+  /** Upload failed */
+  Failed: "failed"
+};
+var Asset = (0, import_canvas_store3.defineCanvasComponent)(
+  { name: "asset", sync: "document", excludeFromHistory: ["uploadState"] },
+  {
+    /** Permanent identifier from AssetProvider (empty until upload complete) */
+    identifier: import_core3.field.string().max(512).default(""),
+    /** Current upload state */
+    uploadState: import_core3.field.enum(UploadState).default(UploadState.Pending)
+  }
+);
+
+// src/components/Color.ts
+var import_canvas_store4 = require("@woven-ecs/canvas-store");
+var import_core4 = require("@woven-ecs/core");
+var ColorSchema = {
+  red: import_core4.field.uint8().default(0),
+  green: import_core4.field.uint8().default(0),
+  blue: import_core4.field.uint8().default(0),
+  alpha: import_core4.field.uint8().default(255)
+};
+var ColorDef = class extends import_canvas_store4.CanvasComponentDef {
+  constructor() {
+    super({ name: "color", sync: "document" }, ColorSchema);
+  }
+  /**
+   * Convert a color to a hex string.
+   */
+  toHex(ctx, entityId) {
+    const { red, green, blue, alpha } = this.read(ctx, entityId);
+    const rHex = red.toString(16).padStart(2, "0");
+    const gHex = green.toString(16).padStart(2, "0");
+    const bHex = blue.toString(16).padStart(2, "0");
+    const aHex = alpha.toString(16).padStart(2, "0");
+    return `#${rHex}${gHex}${bHex}${aHex}`;
+  }
+  /**
+   * Set color from a hex string.
+   */
+  fromHex(ctx, entityId, hex) {
+    const color = this.write(ctx, entityId);
+    color.red = Number.parseInt(hex.slice(1, 3), 16);
+    color.green = Number.parseInt(hex.slice(3, 5), 16);
+    color.blue = Number.parseInt(hex.slice(5, 7), 16);
+    color.alpha = hex.length > 7 ? Number.parseInt(hex.slice(7, 9), 16) : 255;
+  }
+};
+var Color = new ColorDef();
+
+// src/components/Connector.ts
+var import_canvas_store5 = require("@woven-ecs/canvas-store");
+var import_core5 = require("@woven-ecs/core");
+var Connector = (0, import_canvas_store5.defineCanvasComponent)(
+  { name: "connector", sync: "document" },
+  {
+    startBlock: import_core5.field.ref(),
+    startBlockUv: import_core5.field.tuple(import_core5.field.float64(), 2).default([0, 0]),
+    startUv: import_core5.field.tuple(import_core5.field.float64(), 2).default([0, 0]),
+    endBlock: import_core5.field.ref(),
+    endBlockUv: import_core5.field.tuple(import_core5.field.float64(), 2).default([0, 0]),
+    endUv: import_core5.field.tuple(import_core5.field.float64(), 2).default([1, 1])
+  }
+);
+
+// src/components/Edited.ts
+var import_canvas_store6 = require("@woven-ecs/canvas-store");
+var Edited = (0, import_canvas_store6.defineCanvasComponent)({ name: "edited" }, {});
+
+// src/components/Held.ts
+var import_canvas_store7 = require("@woven-ecs/canvas-store");
+var import_core6 = require("@woven-ecs/core");
+var Held = (0, import_canvas_store7.defineCanvasComponent)(
+  { name: "held", sync: "ephemeral" },
+  {
+    sessionId: import_core6.field.string().max(36).default("")
+  }
+);
+
+// src/components/HitGeometry.ts
+var import_math3 = require("@woven-canvas/math");
+var import_canvas_store8 = require("@woven-ecs/canvas-store");
+var import_core7 = require("@woven-ecs/core");
+var _uvToWorldMatrix = [1, 0, 0, 1, 0, 0];
+var MAX_HIT_CAPSULES = 64;
+var FLOATS_PER_CAPSULE = 5;
+var MAX_HIT_ARCS = 2;
+var FLOATS_PER_ARC = 7;
+var HitGeometrySchema = {
+  hitCapsules: import_core7.field.buffer(import_core7.field.float32()).size(MAX_HIT_CAPSULES * FLOATS_PER_CAPSULE),
+  capsuleCount: import_core7.field.uint16().default(0),
+  hitArcs: import_core7.field.buffer(import_core7.field.float32()).size(MAX_HIT_ARCS * FLOATS_PER_ARC),
+  arcCount: import_core7.field.uint16().default(0)
+};
+var HitGeometryDef = class extends import_canvas_store8.CanvasComponentDef {
+  constructor() {
+    super({ name: "hitHeometry" }, HitGeometrySchema);
+  }
+  /**
+   * Get a capsule at a specific index from the hitCapsules buffer.
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param index - Index of the capsule (0-based)
+   * @returns Capsule tuple [ax, ay, bx, by, radius]
+   */
+  getCapsuleAt(ctx, entityId, index) {
+    const hitGeometry = this.read(ctx, entityId);
+    const offset = index * FLOATS_PER_CAPSULE;
+    return [
+      hitGeometry.hitCapsules[offset],
+      hitGeometry.hitCapsules[offset + 1],
+      hitGeometry.hitCapsules[offset + 2],
+      hitGeometry.hitCapsules[offset + 3],
+      hitGeometry.hitCapsules[offset + 4]
+    ];
+  }
+  /**
+   * Set a capsule at a specific index in the hitCapsules buffer.
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param index - Index of the capsule (0-based)
+   * @param capsule - Capsule tuple [ax, ay, bx, by, radius]
+   */
+  setCapsuleAt(ctx, entityId, index, capsule) {
+    const hitGeometry = this.write(ctx, entityId);
+    const offset = index * FLOATS_PER_CAPSULE;
+    for (let i = 0; i < FLOATS_PER_CAPSULE; i++) {
+      hitGeometry.hitCapsules[offset + i] = capsule[i];
+    }
+  }
+  /**
+   * Get an arc at a specific index from the hitArcs buffer.
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param index - Index of the arc (0-based)
+   * @returns Arc tuple [ax, ay, bx, by, cx, cy, thickness]
+   */
+  getArcAt(ctx, entityId, index) {
+    const hitGeometry = this.read(ctx, entityId);
+    const offset = index * FLOATS_PER_ARC;
+    return [
+      hitGeometry.hitArcs[offset],
+      hitGeometry.hitArcs[offset + 1],
+      hitGeometry.hitArcs[offset + 2],
+      hitGeometry.hitArcs[offset + 3],
+      hitGeometry.hitArcs[offset + 4],
+      hitGeometry.hitArcs[offset + 5],
+      hitGeometry.hitArcs[offset + 6]
+    ];
+  }
+  /**
+   * Set an arc at a specific index in the hitArcs buffer.
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param index - Index of the arc (0-based)
+   * @param arc - Arc tuple [ax, ay, bx, by, cx, cy, thickness]
+   */
+  setArcAt(ctx, entityId, index, arc) {
+    const hitGeometry = this.write(ctx, entityId);
+    const offset = index * FLOATS_PER_ARC;
+    for (let i = 0; i < FLOATS_PER_ARC; i++) {
+      hitGeometry.hitArcs[offset + i] = arc[i];
+    }
+  }
+  /**
+   * Check if a point is inside the entity's hit geometry.
+   * Hit geometry is stored in UV coordinates (0-1) relative to the block.
+   * This method transforms UV geometry to world space for intersection testing.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param point - Point to test in world coordinates [x, y]
+   * @returns True if the point is inside any of the entity's hit capsules or arc
+   */
+  containsPointWorld(ctx, entityId, point) {
+    const hitGeometry = this.read(ctx, entityId);
+    Block.getUvToWorldMatrix(ctx, entityId, _uvToWorldMatrix);
+    for (let i = 0; i < hitGeometry.arcCount; i++) {
+      const uvArc = this.getArcAt(ctx, entityId, i);
+      const worldA = [uvArc[0], uvArc[1]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldA);
+      const worldB = [uvArc[2], uvArc[3]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldB);
+      const worldC = [uvArc[4], uvArc[5]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldC);
+      const thickness = uvArc[6];
+      const worldArc = import_math3.Arc.create(worldA[0], worldA[1], worldB[0], worldB[1], worldC[0], worldC[1], thickness);
+      if (import_math3.Arc.containsPoint(worldArc, point)) {
+        return true;
+      }
+    }
+    for (let i = 0; i < hitGeometry.capsuleCount; i++) {
+      const uvCapsule = this.getCapsuleAt(ctx, entityId, i);
+      const worldA = [uvCapsule[0], uvCapsule[1]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldA);
+      const worldB = [uvCapsule[2], uvCapsule[3]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldB);
+      const radius = uvCapsule[4];
+      const worldCapsule = import_math3.Capsule.create(worldA[0], worldA[1], worldB[0], worldB[1], radius);
+      if (import_math3.Capsule.containsPoint(worldCapsule, point)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if an AABB intersects with the entity's hit geometry.
+   * Hit geometry is stored in UV coordinates (0-1) relative to the block.
+   * This method transforms UV geometry to world space for intersection testing.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param aabb - AABB to test in world coordinates [left, top, right, bottom]
+   * @returns True if the AABB intersects any of the entity's hit capsules or arc
+   */
+  intersectsAabbWorld(ctx, entityId, aabb) {
+    const hitGeometry = this.read(ctx, entityId);
+    Block.getUvToWorldMatrix(ctx, entityId, _uvToWorldMatrix);
+    for (let i = 0; i < hitGeometry.arcCount; i++) {
+      const uvArc = this.getArcAt(ctx, entityId, i);
+      const worldA = [uvArc[0], uvArc[1]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldA);
+      const worldB = [uvArc[2], uvArc[3]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldB);
+      const worldC = [uvArc[4], uvArc[5]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldC);
+      const thickness = uvArc[6];
+      const worldArc = import_math3.Arc.create(worldA[0], worldA[1], worldB[0], worldB[1], worldC[0], worldC[1], thickness);
+      if (import_math3.Arc.intersectsAabb(worldArc, aabb)) {
+        return true;
+      }
+    }
+    for (let i = 0; i < hitGeometry.capsuleCount; i++) {
+      const uvCapsule = this.getCapsuleAt(ctx, entityId, i);
+      const worldA = [uvCapsule[0], uvCapsule[1]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldA);
+      const worldB = [uvCapsule[2], uvCapsule[3]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldB);
+      const radius = uvCapsule[4];
+      const worldCapsule = import_math3.Capsule.create(worldA[0], worldA[1], worldB[0], worldB[1], radius);
+      if (import_math3.Capsule.intersectsAabb(worldCapsule, aabb)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get all extrema points of the hit geometry in world coordinates for AABB computation.
+   * Hit geometry is stored in UV coordinates; this transforms them to world space.
+   * Returns corner points expanded by radius/thickness for each capsule and arc.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @returns Array of extrema points in world coordinates
+   */
+  getExtremaWorld(ctx, entityId) {
+    const hitGeometry = this.read(ctx, entityId);
+    const pts = [];
+    Block.getUvToWorldMatrix(ctx, entityId, _uvToWorldMatrix);
+    for (let i = 0; i < hitGeometry.capsuleCount; i++) {
+      const uvCapsule = this.getCapsuleAt(ctx, entityId, i);
+      const worldA = [uvCapsule[0], uvCapsule[1]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldA);
+      const worldB = [uvCapsule[2], uvCapsule[3]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldB);
+      const radius = uvCapsule[4];
+      const worldCapsule = import_math3.Capsule.create(worldA[0], worldA[1], worldB[0], worldB[1], radius);
+      pts.push(...import_math3.Capsule.getExtrema(worldCapsule));
+    }
+    for (let i = 0; i < hitGeometry.arcCount; i++) {
+      const uvArc = this.getArcAt(ctx, entityId, i);
+      const worldA = [uvArc[0], uvArc[1]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldA);
+      const worldB = [uvArc[2], uvArc[3]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldB);
+      const worldC = [uvArc[4], uvArc[5]];
+      import_math3.Mat2.transformPoint(_uvToWorldMatrix, worldC);
+      const thickness = uvArc[6];
+      const worldArc = import_math3.Arc.create(worldA[0], worldA[1], worldB[0], worldB[1], worldC[0], worldC[1], thickness);
+      pts.push(...import_math3.Arc.getExtrema(worldArc));
+    }
+    return pts;
+  }
+  // ============================================
+  // User-facing helper methods for adding hit geometry
+  // ============================================
+  /**
+   * Add a capsule from a capsule tuple [ax, ay, bx, by, radius].
+   * Positions are in UV coordinates (0-1), radius is in world units.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param capsule - Capsule tuple [ax, ay, bx, by, radius]
+   */
+  addCapsule(ctx, entityId, capsule) {
+    const hitGeometry = this.write(ctx, entityId);
+    const index = hitGeometry.capsuleCount;
+    if (index >= MAX_HIT_CAPSULES) {
+      console.warn(`HitGeometry: Max capsules (${MAX_HIT_CAPSULES}) reached`);
+      return;
+    }
+    this.setCapsuleAt(ctx, entityId, index, capsule);
+    hitGeometry.capsuleCount = index + 1;
+  }
+  /**
+   * Add a capsule using UV coordinates.
+   * UV (0,0) is top-left, (1,1) is bottom-right of the block.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param uvA - First endpoint in UV coordinates [0-1, 0-1]
+   * @param uvB - Second endpoint in UV coordinates [0-1, 0-1]
+   * @param worldRadius - Radius in world units (pixels)
+   */
+  addCapsuleUv(ctx, entityId, uvA, uvB, worldRadius) {
+    const capsule = [uvA[0], uvA[1], uvB[0], uvB[1], worldRadius];
+    this.addCapsule(ctx, entityId, capsule);
+  }
+  /**
+   * Add a capsule using world coordinates.
+   * Automatically converts to UV coordinates relative to the block.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param worldA - First endpoint in world coordinates
+   * @param worldB - Second endpoint in world coordinates
+   * @param worldRadius - Radius in world units (pixels)
+   */
+  addCapsuleWorld(ctx, entityId, worldA, worldB, worldRadius) {
+    const uvA = Block.worldToUv(ctx, entityId, worldA);
+    const uvB = Block.worldToUv(ctx, entityId, worldB);
+    this.addCapsuleUv(ctx, entityId, uvA, uvB, worldRadius);
+  }
+  /**
+   * Add an arc from an arc tuple [aX, aY, bX, bY, cX, cY, thickness].
+   * Positions are in UV coordinates (0-1), thickness is in world units.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param arc - Arc tuple [aX, aY, bX, bY, cX, cY, thickness]
+   */
+  addArc(ctx, entityId, arc) {
+    const hitGeometry = this.write(ctx, entityId);
+    const index = hitGeometry.arcCount;
+    if (index >= MAX_HIT_ARCS) {
+      console.warn(`HitGeometry: Max arcs (${MAX_HIT_ARCS}) reached`);
+      return;
+    }
+    this.setArcAt(ctx, entityId, index, arc);
+    hitGeometry.arcCount = index + 1;
+  }
+  /**
+   * Add an arc using UV coordinates.
+   * UV (0,0) is top-left, (1,1) is bottom-right of the block.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param uvA - Start point in UV coordinates
+   * @param uvB - Control point in UV coordinates
+   * @param uvC - End point in UV coordinates
+   * @param worldThickness - Thickness in world units (pixels)
+   */
+  addArcUv(ctx, entityId, uvA, uvB, uvC, worldThickness) {
+    const arc = [uvA[0], uvA[1], uvB[0], uvB[1], uvC[0], uvC[1], worldThickness];
+    this.addArc(ctx, entityId, arc);
+  }
+  /**
+   * Add an arc using world coordinates.
+   * Automatically converts to UV coordinates relative to the block.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   * @param worldA - Start point in world coordinates
+   * @param worldB - Control point in world coordinates
+   * @param worldC - End point in world coordinates
+   * @param worldThickness - Thickness in world units (pixels)
+   */
+  addArcWorld(ctx, entityId, worldA, worldB, worldC, worldThickness) {
+    const uvA = Block.worldToUv(ctx, entityId, worldA);
+    const uvB = Block.worldToUv(ctx, entityId, worldB);
+    const uvC = Block.worldToUv(ctx, entityId, worldC);
+    this.addArcUv(ctx, entityId, uvA, uvB, uvC, worldThickness);
+  }
+  /**
+   * Clear all hit geometry from an entity.
+   *
+   * @param ctx - ECS context
+   * @param entityId - Entity ID
+   */
+  clear(ctx, entityId) {
+    const hitGeometry = this.write(ctx, entityId);
+    hitGeometry.capsuleCount = 0;
+    hitGeometry.arcCount = 0;
+  }
+};
+var HitGeometry = new HitGeometryDef();
+
+// src/components/Hovered.ts
+var import_canvas_store9 = require("@woven-ecs/canvas-store");
+var Hovered = (0, import_canvas_store9.defineCanvasComponent)({ name: "hovered" }, {});
+
+// src/components/Image.ts
+var import_canvas_store10 = require("@woven-ecs/canvas-store");
+var import_core8 = require("@woven-ecs/core");
+var Image = (0, import_canvas_store10.defineCanvasComponent)(
+  { name: "image", sync: "document" },
+  {
+    /** Image width in pixels */
+    width: import_core8.field.uint16().default(0),
+    /** Image height in pixels */
+    height: import_core8.field.uint16().default(0),
+    /** Alt text for accessibility */
+    alt: import_core8.field.string().max(256).default("")
+  }
+);
+
+// src/components/Opacity.ts
+var import_canvas_store11 = require("@woven-ecs/canvas-store");
+var import_core9 = require("@woven-ecs/core");
+var Opacity = (0, import_canvas_store11.defineCanvasComponent)(
+  { name: "opacity" },
+  {
+    value: import_core9.field.uint8().default(255)
+  }
+);
+
+// src/components/Pointer.ts
+var import_canvas_store12 = require("@woven-ecs/canvas-store");
+var import_core10 = require("@woven-ecs/core");
+var PointerButton = {
+  None: "none",
+  Left: "left",
+  Middle: "middle",
+  Right: "right",
+  Back: "back",
+  Forward: "forward"
+};
+var PointerType = {
+  Mouse: "mouse",
+  Pen: "pen",
+  Touch: "touch"
+};
+var SAMPLE_COUNT = 6;
+var PointerSchema = {
+  /** Unique pointer ID (from PointerEvent.pointerId) */
+  pointerId: import_core10.field.uint16().default(0),
+  /** Current position relative to the editor element [x, y] */
+  position: import_core10.field.tuple(import_core10.field.float32(), 2).default([0, 0]),
+  /** Position where the pointer went down [x, y] */
+  downPosition: import_core10.field.tuple(import_core10.field.float32(), 2).default([0, 0]),
+  /** Frame number when the pointer went down (for click detection) */
+  downFrame: import_core10.field.uint32().default(0),
+  /** Which button is pressed */
+  button: import_core10.field.enum(PointerButton).default(PointerButton.None),
+  /** Type of pointer device */
+  pointerType: import_core10.field.enum(PointerType).default(PointerType.Mouse),
+  /** Pressure from 0 to 1 (for pen/touch) */
+  pressure: import_core10.field.float32().default(0),
+  /** Whether the pointer event target was not the editor element */
+  obscured: import_core10.field.boolean().default(false),
+  // Velocity tracking (ring buffer for position samples)
+  /** Ring buffer of previous positions [x0, y0, x1, y1, ...] @internal */
+  _prevPositions: import_core10.field.array(import_core10.field.float32(), SAMPLE_COUNT * 2),
+  /** Ring buffer of timestamps for each position sample @internal */
+  _prevTimes: import_core10.field.array(import_core10.field.float32(), SAMPLE_COUNT),
+  /** Total number of samples added (used for ring buffer indexing) @internal */
+  _sampleCount: import_core10.field.int32().default(0),
+  /** Computed velocity [vx, vy] in pixels per second @internal */
+  _velocity: import_core10.field.tuple(import_core10.field.float32(), 2).default([0, 0])
+};
+var PointerDef = class extends import_canvas_store12.CanvasComponentDef {
+  constructor() {
+    super({ name: "pointer" }, PointerSchema);
+  }
+  /** Get the computed velocity of a pointer */
+  getVelocity(ctx, entityId) {
+    const p = this.read(ctx, entityId);
+    return [p._velocity[0], p._velocity[1]];
+  }
+  /**
+   * Get the pointer button from a PointerEvent button number.
+   * @param button - PointerEvent.button value
+   * @returns PointerButton enum value
+   */
+  getButton(button) {
+    switch (button) {
+      case 0:
+        return PointerButton.Left;
+      case 1:
+        return PointerButton.Middle;
+      case 2:
+        return PointerButton.Right;
+      case 3:
+        return PointerButton.Back;
+      case 4:
+        return PointerButton.Forward;
+      default:
+        return PointerButton.None;
+    }
+  }
+  /**
+   * Get the pointer type from a PointerEvent pointerType string.
+   * @param pointerType - PointerEvent.pointerType value
+   * @returns PointerType enum value
+   */
+  getType(pointerType) {
+    switch (pointerType) {
+      case "pen":
+        return PointerType.Pen;
+      case "touch":
+        return PointerType.Touch;
+      default:
+        return PointerType.Mouse;
+    }
+  }
+};
+var Pointer = new PointerDef();
+function addPointerSample(pointer, position, time) {
+  const currentIndex = pointer._sampleCount % SAMPLE_COUNT;
+  const mostRecentTime = pointer._prevTimes[currentIndex] || 0;
+  if (Math.abs(mostRecentTime - time) < 1e-3) return;
+  pointer.position = position;
+  pointer._sampleCount++;
+  const writeIndex = pointer._sampleCount % SAMPLE_COUNT;
+  pointer._prevPositions[writeIndex * 2] = position[0];
+  pointer._prevPositions[writeIndex * 2 + 1] = position[1];
+  pointer._prevTimes[writeIndex] = time;
+  const pointCount = Math.min(pointer._sampleCount, SAMPLE_COUNT);
+  if (pointCount <= 1) {
+    pointer._velocity = [0, 0];
+    return;
+  }
+  const mod = (n) => (n % SAMPLE_COUNT + SAMPLE_COUNT) % SAMPLE_COUNT;
+  const TAU = 0.04;
+  const EPS = 1e-6;
+  let W = 0;
+  let WU = 0;
+  let WUU = 0;
+  let WX = 0;
+  let WY = 0;
+  let WU_X = 0;
+  let WU_Y = 0;
+  for (let j = 0; j < pointCount; j++) {
+    const idx = mod(pointer._sampleCount - pointCount + 1 + j);
+    const t = pointer._prevTimes[idx] || 0;
+    const u = t - time;
+    const recency = -u;
+    if (recency > 5 * TAU) continue;
+    const w = Math.exp(-recency / TAU);
+    const x = pointer._prevPositions[idx * 2] || 0;
+    const y = pointer._prevPositions[idx * 2 + 1] || 0;
+    W += w;
+    WU += w * u;
+    WUU += w * u * u;
+    WX += w * x;
+    WY += w * y;
+    WU_X += w * u * x;
+    WU_Y += w * u * y;
+  }
+  const denom = W * WUU - WU * WU;
+  if (Math.abs(denom) <= EPS) {
+    const iCurr = pointer._sampleCount % SAMPLE_COUNT;
+    const iPrev = mod(pointer._sampleCount - 1);
+    const dt = (pointer._prevTimes[iCurr] || 0) - (pointer._prevTimes[iPrev] || 0);
+    if (dt > EPS) {
+      const dx = (pointer._prevPositions[iCurr * 2] || 0) - (pointer._prevPositions[iPrev * 2] || 0);
+      const dy = (pointer._prevPositions[iCurr * 2 + 1] || 0) - (pointer._prevPositions[iPrev * 2 + 1] || 0);
+      pointer._velocity = [dx / dt, dy / dt];
+    } else {
+      pointer._velocity = [0, 0];
+    }
+    return;
+  }
+  const vx = (W * WU_X - WU * WX) / denom;
+  const vy = (W * WU_Y - WU * WY) / denom;
+  pointer._velocity = [vx, vy];
+}
+
+// src/components/ScaleWithZoom.ts
+var import_canvas_store13 = require("@woven-ecs/canvas-store");
+var import_core11 = require("@woven-ecs/core");
+var ScaleWithZoom = (0, import_canvas_store13.defineCanvasComponent)(
+  { name: "scaleWithZoom" },
+  {
+    /** Pivot point for scaling as [x, y] (0-1, default 0.5,0.5 = center) */
+    anchor: import_core11.field.tuple(import_core11.field.float64(), 2).default([0.5, 0.5]),
+    /** Initial position as [left, top] at zoom=1 */
+    startPosition: import_core11.field.tuple(import_core11.field.float64(), 2).default([0, 0]),
+    /** Initial size as [width, height] at zoom=1 */
+    startSize: import_core11.field.tuple(import_core11.field.float64(), 2).default([0, 0]),
+    /** Scale multiplier per dimension: [x, y] (0 = no zoom effect, 1 = full zoom effect, 0.5 = half effect) */
+    scaleMultiplier: import_core11.field.tuple(import_core11.field.float64(), 2).default([1, 1])
+  }
+);
+
+// src/components/Shape.ts
+var import_canvas_store14 = require("@woven-ecs/canvas-store");
+var import_core12 = require("@woven-ecs/core");
+var StrokeKind = {
+  Solid: "solid",
+  Dashed: "dashed",
+  None: "none"
+};
+var Shape = (0, import_canvas_store14.defineCanvasComponent)(
+  { name: "shape", sync: "document" },
+  {
+    /** The kind of shape to render (e.g. 'rectangle', 'ellipse', or custom shape key) */
+    kind: import_core12.field.string().default("rectangle"),
+    /** Stroke style */
+    strokeKind: import_core12.field.enum(StrokeKind).default(StrokeKind.Solid),
+    /** Stroke width in pixels */
+    strokeWidth: import_core12.field.uint16().default(2),
+    /** Stroke color - red component (0-255) */
+    strokeRed: import_core12.field.uint8().default(0),
+    /** Stroke color - green component (0-255) */
+    strokeGreen: import_core12.field.uint8().default(0),
+    /** Stroke color - blue component (0-255) */
+    strokeBlue: import_core12.field.uint8().default(0),
+    /** Stroke color - alpha component (0-255) */
+    strokeAlpha: import_core12.field.uint8().default(255),
+    /** Fill color - red component (0-255) */
+    fillRed: import_core12.field.uint8().default(255),
+    /** Fill color - green component (0-255) */
+    fillGreen: import_core12.field.uint8().default(255),
+    /** Fill color - blue component (0-255) */
+    fillBlue: import_core12.field.uint8().default(255),
+    /** Fill color - alpha component (0-255) */
+    fillAlpha: import_core12.field.uint8().default(0)
+  }
+);
+
+// src/components/Text.ts
+var import_canvas_store15 = require("@woven-ecs/canvas-store");
+var import_core13 = require("@woven-ecs/core");
+
+// src/types.ts
+var import_zod = require("zod");
+function generateUserColor() {
+  const colors = [
+    "#f43f5e",
+    // rose
+    "#ec4899",
+    // pink
+    "#a855f7",
+    // purple
+    "#6366f1",
+    // indigo
+    "#3b82f6",
+    // blue
+    "#0ea5e9",
+    // sky
+    "#14b8a6",
+    // teal
+    "#22c55e",
+    // green
+    "#eab308",
+    // yellow
+    "#f97316"
+    // orange
+  ];
+  return colors[Math.floor(Math.random() * colors.length)];
+}
+var UserData = import_zod.z.object({
+  userId: import_zod.z.string().max(36).default(() => crypto.randomUUID()),
+  sessionId: import_zod.z.string().max(36).default(() => crypto.randomUUID()),
+  color: import_zod.z.string().max(7).default(generateUserColor),
+  name: import_zod.z.string().max(100).default("Anonymous"),
+  avatar: import_zod.z.string().max(500).default("")
+});
+function getPluginResources(ctx, pluginName) {
+  const resources = ctx.resources;
+  return resources.pluginResources[pluginName];
+}
+var GridOptions = import_zod.z.object({
+  /**
+   * Whether grid snapping is enabled.
+   * @default true
+   */
+  enabled: import_zod.z.boolean().default(true),
+  /**
+   * Whether resized/rotated objects must stay aligned to the grid.
+   * If true, objects snap to grid during resize/rotate.
+   * If false, objects scale proportionally to the transform box, which may
+   * cause them to be unaligned with the grid.
+   * @default false
+   */
+  strict: import_zod.z.boolean().default(false),
+  /**
+   * Width of each grid column in world units.
+   * @default 20
+   */
+  colWidth: import_zod.z.number().nonnegative().default(20),
+  /**
+   * Height of each grid row in world units.
+   * @default 20
+   */
+  rowHeight: import_zod.z.number().nonnegative().default(20),
+  /**
+   * Angular snap increment in radians when grid is enabled.
+   * @default Math.PI / 36 (5 degrees)
+   */
+  snapAngleRad: import_zod.z.number().nonnegative().default(Math.PI / 36),
+  /**
+   * Angular snap increment in radians when shift key is held.
+   * @default Math.PI / 12 (15 degrees)
+   */
+  shiftSnapAngleRad: import_zod.z.number().nonnegative().default(Math.PI / 12)
+});
+var ControlsOptions = import_zod.z.object({
+  /**
+   * Tool activated by left mouse button.
+   * @default 'select'
+   */
+  leftMouseTool: import_zod.z.string().max(32).default("select"),
+  /**
+   * Tool activated by middle mouse button.
+   * @default 'hand'
+   */
+  middleMouseTool: import_zod.z.string().max(32).default("hand"),
+  /**
+   * Tool activated by right mouse button.
+   * @default 'menu'
+   */
+  rightMouseTool: import_zod.z.string().max(32).default("menu"),
+  /**
+   * Tool activated by mouse wheel.
+   * @default 'scroll'
+   */
+  wheelTool: import_zod.z.string().max(32).default("scroll"),
+  /**
+   * Tool activated by mouse wheel with modifier key held.
+   * @default 'zoom'
+   */
+  modWheelTool: import_zod.z.string().max(32).default("zoom")
+});
+var EditorOptionsSchema = import_zod.z.object({
+  /**
+   * Plugins to load.
+   * Plugins are sorted by dependencies automatically.
+   */
+  plugins: import_zod.z.array(import_zod.z.custom()).default([]),
+  /**
+   * Maximum number of entities.
+   * @default 5_000
+   */
+  maxEntities: import_zod.z.number().default(5e3),
+  /**
+   * User data for presence tracking.
+   * All fields are optional - defaults will be applied.
+   */
+  user: import_zod.z.custom().default({}),
+  /**
+   * Grid configuration for snap-to-grid behavior.
+   * All fields are optional - defaults will be applied.
+   */
+  grid: import_zod.z.custom().default({}),
+  /**
+   * Custom block definitions.
+   * Accepts partial block definitions - defaults will be applied automatically.
+   */
+  blockDefs: import_zod.z.array(import_zod.z.custom()).default([]),
+  /**
+   * Keybind definitions for keyboard shortcuts.
+   * These map key combinations to plugin commands.
+   */
+  keybinds: import_zod.z.array(import_zod.z.custom()).default([]),
+  /**
+   * Custom cursor definitions.
+   * Override default cursors or define new ones for transform operations.
+   */
+  cursors: import_zod.z.record(import_zod.z.string(), import_zod.z.custom()).default({}),
+  /**
+   * Custom components to register without creating a plugin.
+   */
+  components: import_zod.z.array(import_zod.z.custom()).default([]),
+  /**
+   * Custom singletons to register without creating a plugin.
+   */
+  singletons: import_zod.z.array(import_zod.z.custom()).default([]),
+  /**
+   * Custom systems to register without creating a plugin.
+   * Each system specifies its phase and priority.
+   */
+  systems: import_zod.z.array(import_zod.z.custom()).default([]),
+  /**
+   * Custom font families to load and make available in the font selector.
+   * Fonts will be loaded automatically during editor initialization.
+   */
+  fonts: import_zod.z.array(import_zod.z.custom()).default([]),
+  /**
+   * If true, keybinds from plugins will be ignored.
+   * Use this when you want full control over keybinds.
+   */
+  omitPluginKeybinds: import_zod.z.boolean().default(false),
+  /**
+   * If true, cursors from plugins will be ignored.
+   * Use this when you want full control over cursors.
+   */
+  omitPluginCursors: import_zod.z.boolean().default(false),
+  /**
+   * If true, fonts from plugins will be ignored.
+   * Use this when you want full control over fonts.
+   */
+  omitPluginFonts: import_zod.z.boolean().default(false),
+  /**
+   * Initial controls configuration.
+   * Override default tool mappings for mouse buttons, wheel, etc.
+   *
+   * @example
+   * ```typescript
+   * controls: {
+   *   leftMouseTool: 'pen',      // Start with pen tool active
+   *   middleMouseTool: 'hand',   // Middle mouse pans
+   * }
+   * ```
+   */
+  controls: import_zod.z.custom().optional()
+});
+var Keybind = import_zod.z.object({
+  /** The command to execute when this keybind is triggered */
+  command: import_zod.z.string(),
+  /** The key index from the Key constants (e.g., Key.A, Key.Delete) */
+  key: import_zod.z.number(),
+  /** Whether the modifier key (Cmd on Mac, Ctrl on Windows) must be held */
+  mod: import_zod.z.boolean().optional(),
+  /** Whether the Shift key must be held */
+  shift: import_zod.z.boolean().optional()
+});
+var CursorDef = import_zod.z.object({
+  /** Function that generates the SVG string for a given rotation angle (in radians) */
+  makeSvg: import_zod.z.function({ input: import_zod.z.tuple([import_zod.z.number()]), output: import_zod.z.string() }),
+  /** Hotspot coordinates [x, y] for the cursor */
+  hotspot: import_zod.z.tuple([import_zod.z.number(), import_zod.z.number()]),
+  /** Base rotation offset applied before the dynamic rotation */
+  rotationOffset: import_zod.z.number()
+});
+var VerticalAlignment = {
+  Top: "top",
+  Center: "center",
+  Bottom: "bottom"
+};
+var TextAlignment = {
+  Left: "left",
+  Center: "center",
+  Right: "right",
+  Justify: "justify"
+};
+var BlockDefEditOptions = import_zod.z.object({
+  canEdit: import_zod.z.boolean().default(false),
+  removeWhenTextEmpty: import_zod.z.boolean().default(false)
+});
+var BlockDefConnectors = import_zod.z.object({
+  /** Whether connectors are enabled for this block type */
+  enabled: import_zod.z.boolean().default(true),
+  /** UV coordinates of terminal positions (0-1 range, where [0,0] is top-left) */
+  terminals: import_zod.z.array(import_zod.z.tuple([import_zod.z.number(), import_zod.z.number()])).default([
+    [0.5, 0],
+    // top
+    [0.5, 1],
+    // bottom
+    [0.5, 0.5],
+    // center
+    [0, 0.5],
+    // left
+    [1, 0.5]
+    // right
+  ])
+});
+var Stratum = import_zod.z.enum(["background", "content", "overlay"]);
+var BlockDef2 = import_zod.z.object({
+  tag: import_zod.z.string(),
+  stratum: Stratum.default("content"),
+  editOptions: BlockDefEditOptions.default(BlockDefEditOptions.parse({})),
+  components: import_zod.z.array(import_zod.z.custom()).default([]),
+  resizeMode: import_zod.z.enum(["scale", "text", "free", "groupOnly"]).default("scale"),
+  canRotate: import_zod.z.boolean().default(true),
+  canScale: import_zod.z.boolean().default(true),
+  connectors: BlockDefConnectors.default(BlockDefConnectors.parse({}))
+});
+
+// src/components/Text.ts
+var Text = (0, import_canvas_store15.defineCanvasComponent)(
+  { name: "text", sync: "document" },
+  {
+    /** HTML content (supports rich text formatting) */
+    content: import_core13.field.string().max(1e4).default(""),
+    /** Font size in pixels */
+    fontSizePx: import_core13.field.float64().default(24),
+    /** Font family name */
+    fontFamily: import_core13.field.string().max(64).default("Figtree"),
+    /** Line height multiplier */
+    lineHeight: import_core13.field.float64().default(1.2),
+    /** Letter spacing in em units */
+    letterSpacingEm: import_core13.field.float64().default(0),
+    /** Whether width is constrained (text wraps) */
+    constrainWidth: import_core13.field.boolean().default(true),
+    /** Default text alignment for new paragraphs */
+    defaultAlignment: import_core13.field.enum(TextAlignment).default(TextAlignment.Left)
+  }
+);
+
+// src/components/User.ts
+var import_canvas_store16 = require("@woven-ecs/canvas-store");
+var import_core14 = require("@woven-ecs/core");
+var User = (0, import_canvas_store16.defineCanvasComponent)(
+  { name: "user", sync: "ephemeral" },
+  {
+    userId: import_core14.field.string().max(36),
+    sessionId: import_core14.field.string().max(36),
+    color: import_core14.field.string().max(7),
+    name: import_core14.field.string().max(100),
+    avatar: import_core14.field.string().max(500),
+    position: import_core14.field.tuple(import_core14.field.float32(), 2).default([0, 0])
+  }
+);
+
+// src/components/VerticalAlign.ts
+var import_canvas_store17 = require("@woven-ecs/canvas-store");
+var import_core15 = require("@woven-ecs/core");
+var VerticalAlign = (0, import_canvas_store17.defineCanvasComponent)(
+  { name: "verticalAlign", sync: "document" },
+  {
+    value: import_core15.field.enum(VerticalAlignment).default(VerticalAlignment.Top)
+  }
+);
+
+// src/constants.ts
+var PLUGIN_NAME = "core";
+var STRATUM_ORDER = {
+  background: 0,
+  content: 1,
+  overlay: 2
+};
+
+// src/singletons/index.ts
+var singletons_exports = {};
+__export(singletons_exports, {
+  Camera: () => Camera,
+  Controls: () => Controls,
+  Cursor: () => Cursor,
+  Frame: () => Frame,
+  Grid: () => Grid,
+  Intersect: () => Intersect,
+  Key: () => Key,
+  Keyboard: () => Keyboard,
+  Mouse: () => Mouse,
+  RankBounds: () => RankBounds,
+  ScaleWithZoomState: () => ScaleWithZoomState,
+  Screen: () => Screen,
+  clearBits: () => clearBits,
+  codeToIndex: () => codeToIndex,
+  setBit: () => setBit
+});
+
+// src/singletons/Camera.ts
+var import_canvas_store19 = require("@woven-ecs/canvas-store");
+var import_core17 = require("@woven-ecs/core");
+
+// src/singletons/Screen.ts
+var import_canvas_store18 = require("@woven-ecs/canvas-store");
+var import_core16 = require("@woven-ecs/core");
+var ScreenSchema = {
+  /** Width of the editor element in pixels */
+  width: import_core16.field.float64().default(0),
+  /** Height of the editor element in pixels */
+  height: import_core16.field.float64().default(0),
+  /** Left offset of the editor element relative to the viewport */
+  left: import_core16.field.float64().default(0),
+  /** Top offset of the editor element relative to the viewport */
+  top: import_core16.field.float64().default(0)
+};
+var ScreenDef = class extends import_canvas_store18.CanvasSingletonDef {
+  constructor() {
+    super({ name: "screen" }, ScreenSchema);
+  }
+  /** Get screen dimensions as [width, height] */
+  getSize(ctx) {
+    const s = this.read(ctx);
+    return [s.width, s.height];
+  }
+  /** Get screen position as [left, top] */
+  getPosition(ctx) {
+    const s = this.read(ctx);
+    return [s.left, s.top];
+  }
+  /** Get the center point of the screen */
+  getCenter(ctx) {
+    const s = this.read(ctx);
+    return [s.left + s.width / 2, s.top + s.height / 2];
+  }
+};
+var Screen = new ScreenDef();
+
+// src/singletons/Camera.ts
+var CameraSchema = {
+  /** Top position of the camera in world coordinates */
+  top: import_core17.field.float64().default(0),
+  /** Left position of the camera in world coordinates */
+  left: import_core17.field.float64().default(0),
+  /** Zoom level (1 = 100%, 2 = 200%, 0.5 = 50%) */
+  zoom: import_core17.field.float64().default(1),
+  /** Whether the camera viewport intersects any blocks */
+  canSeeBlocks: import_core17.field.boolean().default(true),
+  /** Reference to a block that the camera can currently see (for optimization) */
+  lastSeenBlock: import_core17.field.ref()
+};
+var CameraDef = class extends import_canvas_store19.CanvasSingletonDef {
+  constructor() {
+    super({ name: "camera", sync: "local" }, CameraSchema);
+  }
+  /**
+   * Convert screen coordinates to world coordinates.
+   * @param ctx - ECS context
+   * @param screenPos - Position in screen pixels [x, y]
+   * @returns Position in world coordinates [x, y]
+   */
+  toWorld(ctx, screenPos) {
+    const camera = this.read(ctx);
+    const worldX = camera.left + screenPos[0] / camera.zoom;
+    const worldY = camera.top + screenPos[1] / camera.zoom;
+    return [worldX, worldY];
+  }
+  /**
+   * Convert world coordinates to screen coordinates.
+   * @param ctx - ECS context
+   * @param worldPos - Position in world coordinates [x, y]
+   * @returns Position in screen pixels [x, y]
+   */
+  toScreen(ctx, worldPos) {
+    const camera = this.read(ctx);
+    const screenX = (worldPos[0] - camera.left) * camera.zoom;
+    const screenY = (worldPos[1] - camera.top) * camera.zoom;
+    return [screenX, screenY];
+  }
+  /**
+   * Get the world coordinates of the viewport center.
+   * @param ctx - ECS context
+   * @returns Center position in world coordinates [x, y]
+   */
+  getWorldCenter(ctx) {
+    const camera = this.read(ctx);
+    const screen = Screen.read(ctx);
+    return [camera.left + screen.width / camera.zoom / 2, camera.top + screen.height / camera.zoom / 2];
+  }
+  /**
+   * Get the world-space bounds of the visible viewport.
+   * @param ctx - ECS context
+   * @returns Bounds as { left, top, right, bottom } in world coordinates
+   */
+  getWorldBounds(ctx) {
+    const camera = this.read(ctx);
+    const screen = Screen.read(ctx);
+    return {
+      left: camera.left,
+      top: camera.top,
+      right: camera.left + screen.width / camera.zoom,
+      bottom: camera.top + screen.height / camera.zoom
+    };
+  }
+  /**
+   * Get the camera viewport as an AABB tuple [left, top, right, bottom].
+   * @param ctx - ECS context
+   * @param out - Optional output array to write to (avoids allocation)
+   * @returns AABB tuple in world coordinates
+   */
+  getAabb(ctx, out) {
+    const camera = this.read(ctx);
+    const screen = Screen.read(ctx);
+    const result = out ?? [0, 0, 0, 0];
+    result[0] = camera.left;
+    result[1] = camera.top;
+    result[2] = camera.left + screen.width / camera.zoom;
+    result[3] = camera.top + screen.height / camera.zoom;
+    return result;
+  }
+};
+var Camera = new CameraDef();
+
+// src/singletons/Controls.ts
+var import_canvas_store20 = require("@woven-ecs/canvas-store");
+var import_core18 = require("@woven-ecs/core");
+var ControlsSchema = {
+  /** Tool activated by left mouse button */
+  leftMouseTool: import_core18.field.string().max(32).default("select"),
+  /** Tool activated by middle mouse button */
+  middleMouseTool: import_core18.field.string().max(32).default("hand"),
+  /** Tool activated by right mouse button */
+  rightMouseTool: import_core18.field.string().max(32).default("menu"),
+  /** Tool activated by mouse wheel */
+  wheelTool: import_core18.field.string().max(32).default("scroll"),
+  /** Tool activated by mouse wheel with modifier key held */
+  modWheelTool: import_core18.field.string().max(32).default("zoom"),
+  /** JSON snapshot of block to place on next click (empty string = no placement active) */
+  heldSnapshot: import_core18.field.string().max(4096).default("")
+};
+var ControlsDef = class extends import_canvas_store20.CanvasSingletonDef {
+  constructor() {
+    super({ name: "controls" }, ControlsSchema);
+  }
+  /**
+   * Get the pointer buttons that are mapped to the given tools.
+   * @param ctx - ECS context
+   * @param tools - Tool names to check
+   * @returns Array of PointerButton values that activate any of the given tools
+   */
+  getButtons(ctx, ...tools) {
+    const controls = this.read(ctx);
+    const buttons = [];
+    if (tools.includes(controls.leftMouseTool)) {
+      buttons.push(PointerButton.Left);
+    }
+    if (tools.includes(controls.middleMouseTool)) {
+      buttons.push(PointerButton.Middle);
+    }
+    if (tools.includes(controls.rightMouseTool)) {
+      buttons.push(PointerButton.Right);
+    }
+    return buttons;
+  }
+  /**
+   * Check if a wheel tool is active based on modifier key state.
+   * @param ctx - ECS context
+   * @param tool - Tool name to check
+   * @param modDown - Whether the modifier key is held
+   * @returns True if the given tool is active for wheel input
+   */
+  wheelActive(ctx, tool, modDown) {
+    const controls = this.read(ctx);
+    return controls.wheelTool === tool && !modDown || controls.modWheelTool === tool && modDown;
+  }
+};
+var Controls = new ControlsDef();
+
+// src/singletons/Cursor.ts
+var import_canvas_store21 = require("@woven-ecs/canvas-store");
+var import_core19 = require("@woven-ecs/core");
+var CursorSchema = {
+  /** Base cursor kind (from current tool) */
+  cursorKind: import_core19.field.string().max(64).default("select"),
+  /** Base cursor rotation in radians */
+  rotation: import_core19.field.float64().default(0),
+  /** Context-specific cursor kind (overrides cursorKind when set, e.g., during drag/hover) */
+  contextCursorKind: import_core19.field.string().max(64).default(""),
+  /** Context cursor rotation in radians */
+  contextRotation: import_core19.field.float64().default(0)
+};
+var CursorDef2 = class extends import_canvas_store21.CanvasSingletonDef {
+  constructor() {
+    super({ name: "cursor" }, CursorSchema);
+  }
+  /**
+   * Get the effective cursor kind and rotation (context if set, otherwise base).
+   */
+  getEffective(ctx) {
+    const cursor = this.read(ctx);
+    if (cursor.contextCursorKind) {
+      return {
+        cursorKind: cursor.contextCursorKind,
+        rotation: cursor.contextRotation
+      };
+    }
+    return { cursorKind: cursor.cursorKind, rotation: cursor.rotation };
+  }
+  /**
+   * Set the base cursor kind and rotation.
+   */
+  setCursor(ctx, cursorKind, rotation = 0) {
+    const cursor = this.write(ctx);
+    cursor.cursorKind = cursorKind;
+    cursor.rotation = rotation;
+  }
+  /**
+   * Set the context cursor kind and rotation (temporary override).
+   */
+  setContextCursor(ctx, cursorKind, rotation = 0) {
+    const cursor = this.write(ctx);
+    cursor.contextCursorKind = cursorKind;
+    cursor.contextRotation = rotation;
+  }
+  /**
+   * Clear the context cursor.
+   */
+  clearContextCursor(ctx) {
+    const cursor = this.write(ctx);
+    cursor.contextCursorKind = "";
+    cursor.contextRotation = 0;
+  }
+};
+var Cursor = new CursorDef2();
+
+// src/singletons/Frame.ts
+var import_canvas_store22 = require("@woven-ecs/canvas-store");
+var import_core20 = require("@woven-ecs/core");
+var Frame = (0, import_canvas_store22.defineCanvasSingleton)(
+  { name: "frame" },
+  {
+    /** Current frame number (increments each tick) */
+    number: import_core20.field.uint32().default(0),
+    /** Time since last frame in seconds */
+    delta: import_core20.field.float64().default(0),
+    /** Timestamp of current frame in milliseconds (from performance.now()) */
+    time: import_core20.field.float64().default(0),
+    /** Timestamp of previous frame in milliseconds (0 if first frame) */
+    lastTime: import_core20.field.float64().default(0)
+  }
+);
+
+// src/singletons/Grid.ts
+var import_canvas_store23 = require("@woven-ecs/canvas-store");
+var import_core21 = require("@woven-ecs/core");
+var GridSchema = {
+  /** Whether grid snapping is enabled */
+  enabled: import_core21.field.boolean().default(false),
+  /** Whether resized/rotated objects must stay aligned to the grid */
+  strict: import_core21.field.boolean().default(false),
+  /** Width of each grid column in world units */
+  colWidth: import_core21.field.float64().default(20),
+  /** Height of each grid row in world units */
+  rowHeight: import_core21.field.float64().default(20),
+  /** Angular snap increment in radians when grid is enabled */
+  snapAngleRad: import_core21.field.float64().default(Math.PI / 36),
+  /** Angular snap increment in radians when shift key is held */
+  shiftSnapAngleRad: import_core21.field.float64().default(Math.PI / 12)
+};
+var GridDef = class extends import_canvas_store23.CanvasSingletonDef {
+  constructor() {
+    super({ name: "grid" }, GridSchema);
+  }
+  /**
+   * Snap a position to the grid.
+   * @param ctx - ECS context
+   * @param position - Position to snap [x, y] (mutated in place)
+   */
+  snapPosition(ctx, position) {
+    const grid = this.read(ctx);
+    if (!grid.enabled) return;
+    if (grid.colWidth !== 0) {
+      position[0] = Math.round(position[0] / grid.colWidth) * grid.colWidth;
+    }
+    if (grid.rowHeight !== 0) {
+      position[1] = Math.round(position[1] / grid.rowHeight) * grid.rowHeight;
+    }
+  }
+  /**
+   * Snap a size to the grid (minimum one grid cell).
+   * @param ctx - ECS context
+   * @param size - Size to snap [width, height] (mutated in place)
+   */
+  snapSize(ctx, size) {
+    const grid = this.read(ctx);
+    if (!grid.enabled) return;
+    if (grid.colWidth !== 0) {
+      size[0] = Math.max(grid.colWidth, Math.round(size[0] / grid.colWidth) * grid.colWidth);
+    }
+    if (grid.rowHeight !== 0) {
+      size[1] = Math.max(grid.rowHeight, Math.round(size[1] / grid.rowHeight) * grid.rowHeight);
+    }
+  }
+  /**
+   * Snap a value to the grid column width.
+   * @param ctx - ECS context
+   * @param value - Value to snap
+   * @returns Snapped value, or original if grid disabled
+   */
+  snapX(ctx, value) {
+    const grid = this.read(ctx);
+    if (!grid.enabled || grid.colWidth === 0) return value;
+    return Math.round(value / grid.colWidth) * grid.colWidth;
+  }
+  /**
+   * Snap a value to the grid row height.
+   * @param ctx - ECS context
+   * @param value - Value to snap
+   * @returns Snapped value, or original if grid disabled
+   */
+  snapY(ctx, value) {
+    const grid = this.read(ctx);
+    if (!grid.enabled || grid.rowHeight === 0) return value;
+    return Math.round(value / grid.rowHeight) * grid.rowHeight;
+  }
+};
+var Grid = new GridDef();
+
+// src/singletons/Intersect.ts
+var import_canvas_store24 = require("@woven-ecs/canvas-store");
+var import_core22 = require("@woven-ecs/core");
+var IntersectSchema = {
+  // Store up to 5 intersected entity IDs
+  entity1: import_core22.field.ref(),
+  entity2: import_core22.field.ref(),
+  entity3: import_core22.field.ref(),
+  entity4: import_core22.field.ref(),
+  entity5: import_core22.field.ref()
+};
+var IntersectDef = class extends import_canvas_store24.CanvasSingletonDef {
+  constructor() {
+    super({ name: "intersect" }, IntersectSchema);
+  }
+  /**
+   * Get the topmost intersected entity.
+   */
+  getTop(ctx) {
+    return this.read(ctx).entity1;
+  }
+  /**
+   * Get all intersected entities as an array.
+   */
+  getAll(ctx) {
+    const intersect = this.read(ctx);
+    const result = [];
+    if (intersect.entity1 !== null) result.push(intersect.entity1);
+    if (intersect.entity2 !== null) result.push(intersect.entity2);
+    if (intersect.entity3 !== null) result.push(intersect.entity3);
+    if (intersect.entity4 !== null) result.push(intersect.entity4);
+    if (intersect.entity5 !== null) result.push(intersect.entity5);
+    return result;
+  }
+  /**
+   * Set intersected entities from an array.
+   */
+  setAll(ctx, entities) {
+    const intersect = this.write(ctx);
+    intersect.entity1 = entities[0] ?? null;
+    intersect.entity2 = entities[1] ?? null;
+    intersect.entity3 = entities[2] ?? null;
+    intersect.entity4 = entities[3] ?? null;
+    intersect.entity5 = entities[4] ?? null;
+  }
+  /**
+   * Clear all intersections.
+   */
+  clear(ctx) {
+    const intersect = this.write(ctx);
+    intersect.entity1 = null;
+    intersect.entity2 = null;
+    intersect.entity3 = null;
+    intersect.entity4 = null;
+    intersect.entity5 = null;
+  }
+};
+var Intersect = new IntersectDef();
+
+// src/singletons/Keyboard.ts
+var import_canvas_store25 = require("@woven-ecs/canvas-store");
+var import_core23 = require("@woven-ecs/core");
+var KEY_BUFFER_SIZE = 32;
+var KeyboardSchema = {
+  /**
+   * Buffer where each bit represents whether a key is currently pressed.
+   * Uses field.buffer for zero-allocation subarray views.
+   */
+  keysDown: import_core23.field.buffer(import_core23.field.uint8()).size(KEY_BUFFER_SIZE),
+  /**
+   * Buffer for key-down triggers (true for exactly 1 frame when key is pressed).
+   * Uses field.buffer for zero-allocation subarray views.
+   */
+  keysDownTrigger: import_core23.field.buffer(import_core23.field.uint8()).size(KEY_BUFFER_SIZE),
+  /**
+   * Buffer for key-up triggers (true for exactly 1 frame when key is released).
+   * Uses field.buffer for zero-allocation subarray views.
+   */
+  keysUpTrigger: import_core23.field.buffer(import_core23.field.uint8()).size(KEY_BUFFER_SIZE),
+  /** Common modifier - Shift key is down */
+  shiftDown: import_core23.field.boolean().default(false),
+  /** Common modifier - Alt/Option key is down */
+  altDown: import_core23.field.boolean().default(false),
+  /** Common modifier - Ctrl (Windows/Linux) or Cmd (Mac) is down */
+  modDown: import_core23.field.boolean().default(false)
+};
+function getBit(buffer, bitIndex) {
+  if (bitIndex < 0 || bitIndex >= buffer.length * 8) return false;
+  const byteIndex = Math.floor(bitIndex / 8);
+  const bitOffset = bitIndex % 8;
+  return (buffer[byteIndex] & 1 << bitOffset) !== 0;
+}
+var KeyboardDef = class extends import_canvas_store25.CanvasSingletonDef {
+  constructor() {
+    super({ name: "keyboard" }, KeyboardSchema);
+  }
+  /**
+   * Check if a key is currently pressed.
+   * @param ctx - Editor context
+   * @param key - The key index to check (use Key.A, Key.Space, etc.)
+   */
+  isKeyDown(ctx, key) {
+    return getBit(this.read(ctx).keysDown, key);
+  }
+  /**
+   * Check if a key was just pressed this frame.
+   * @param ctx - Editor context
+   * @param key - The key index to check (use Key.A, Key.Space, etc.)
+   */
+  isKeyDownTrigger(ctx, key) {
+    return getBit(this.read(ctx).keysDownTrigger, key);
+  }
+  /**
+   * Check if a key was just released this frame.
+   * @param ctx - Editor context
+   * @param key - The key index to check (use Key.A, Key.Space, etc.)
+   */
+  isKeyUpTrigger(ctx, key) {
+    return getBit(this.read(ctx).keysUpTrigger, key);
+  }
+};
+var Keyboard = new KeyboardDef();
+function setBit(buffer, bitIndex, value) {
+  if (bitIndex < 0 || bitIndex >= buffer.length * 8) return;
+  const byteIndex = Math.floor(bitIndex / 8);
+  const bitOffset = bitIndex % 8;
+  if (value) {
+    buffer[byteIndex] |= 1 << bitOffset;
+  } else {
+    buffer[byteIndex] &= ~(1 << bitOffset);
+  }
+}
+function clearBits(buffer) {
+  for (let i = 0; i < buffer.length; i++) {
+    buffer[i] = 0;
+  }
+}
+var codeToIndex = {
+  // Letters (0-25)
+  KeyA: 0,
+  KeyB: 1,
+  KeyC: 2,
+  KeyD: 3,
+  KeyE: 4,
+  KeyF: 5,
+  KeyG: 6,
+  KeyH: 7,
+  KeyI: 8,
+  KeyJ: 9,
+  KeyK: 10,
+  KeyL: 11,
+  KeyM: 12,
+  KeyN: 13,
+  KeyO: 14,
+  KeyP: 15,
+  KeyQ: 16,
+  KeyR: 17,
+  KeyS: 18,
+  KeyT: 19,
+  KeyU: 20,
+  KeyV: 21,
+  KeyW: 22,
+  KeyX: 23,
+  KeyY: 24,
+  KeyZ: 25,
+  // Numbers (26-35)
+  Digit0: 26,
+  Digit1: 27,
+  Digit2: 28,
+  Digit3: 29,
+  Digit4: 30,
+  Digit5: 31,
+  Digit6: 32,
+  Digit7: 33,
+  Digit8: 34,
+  Digit9: 35,
+  // Function keys (36-47)
+  F1: 36,
+  F2: 37,
+  F3: 38,
+  F4: 39,
+  F5: 40,
+  F6: 41,
+  F7: 42,
+  F8: 43,
+  F9: 44,
+  F10: 45,
+  F11: 46,
+  F12: 47,
+  // Modifiers (48-51)
+  ShiftLeft: 48,
+  ShiftRight: 49,
+  ControlLeft: 50,
+  ControlRight: 51,
+  AltLeft: 52,
+  AltRight: 53,
+  MetaLeft: 54,
+  MetaRight: 55,
+  // Navigation (56-71)
+  Escape: 56,
+  Space: 57,
+  Enter: 58,
+  Tab: 59,
+  Backspace: 60,
+  Delete: 61,
+  ArrowLeft: 62,
+  ArrowUp: 63,
+  ArrowRight: 64,
+  ArrowDown: 65,
+  Home: 66,
+  End: 67,
+  PageUp: 68,
+  PageDown: 69,
+  Insert: 70,
+  // Punctuation (72-83)
+  Semicolon: 72,
+  Equal: 73,
+  Comma: 74,
+  Minus: 75,
+  Period: 76,
+  Slash: 77,
+  Backquote: 78,
+  BracketLeft: 79,
+  Backslash: 80,
+  BracketRight: 81,
+  Quote: 82,
+  // Numpad (84-99)
+  Numpad0: 84,
+  Numpad1: 85,
+  Numpad2: 86,
+  Numpad3: 87,
+  Numpad4: 88,
+  Numpad5: 89,
+  Numpad6: 90,
+  Numpad7: 91,
+  Numpad8: 92,
+  Numpad9: 93,
+  NumpadAdd: 94,
+  NumpadSubtract: 95,
+  NumpadMultiply: 96,
+  NumpadDivide: 97,
+  NumpadDecimal: 98,
+  NumpadEnter: 99
+};
+var Key = {
+  // Letters
+  A: codeToIndex.KeyA,
+  B: codeToIndex.KeyB,
+  C: codeToIndex.KeyC,
+  D: codeToIndex.KeyD,
+  E: codeToIndex.KeyE,
+  F: codeToIndex.KeyF,
+  G: codeToIndex.KeyG,
+  H: codeToIndex.KeyH,
+  I: codeToIndex.KeyI,
+  J: codeToIndex.KeyJ,
+  K: codeToIndex.KeyK,
+  L: codeToIndex.KeyL,
+  M: codeToIndex.KeyM,
+  N: codeToIndex.KeyN,
+  O: codeToIndex.KeyO,
+  P: codeToIndex.KeyP,
+  Q: codeToIndex.KeyQ,
+  R: codeToIndex.KeyR,
+  S: codeToIndex.KeyS,
+  T: codeToIndex.KeyT,
+  U: codeToIndex.KeyU,
+  V: codeToIndex.KeyV,
+  W: codeToIndex.KeyW,
+  X: codeToIndex.KeyX,
+  Y: codeToIndex.KeyY,
+  Z: codeToIndex.KeyZ,
+  // Numbers
+  Digit0: codeToIndex.Digit0,
+  Digit1: codeToIndex.Digit1,
+  Digit2: codeToIndex.Digit2,
+  Digit3: codeToIndex.Digit3,
+  Digit4: codeToIndex.Digit4,
+  Digit5: codeToIndex.Digit5,
+  Digit6: codeToIndex.Digit6,
+  Digit7: codeToIndex.Digit7,
+  Digit8: codeToIndex.Digit8,
+  Digit9: codeToIndex.Digit9,
+  // Function keys
+  F1: codeToIndex.F1,
+  F2: codeToIndex.F2,
+  F3: codeToIndex.F3,
+  F4: codeToIndex.F4,
+  F5: codeToIndex.F5,
+  F6: codeToIndex.F6,
+  F7: codeToIndex.F7,
+  F8: codeToIndex.F8,
+  F9: codeToIndex.F9,
+  F10: codeToIndex.F10,
+  F11: codeToIndex.F11,
+  F12: codeToIndex.F12,
+  // Modifiers
+  ShiftLeft: codeToIndex.ShiftLeft,
+  ShiftRight: codeToIndex.ShiftRight,
+  ControlLeft: codeToIndex.ControlLeft,
+  ControlRight: codeToIndex.ControlRight,
+  AltLeft: codeToIndex.AltLeft,
+  AltRight: codeToIndex.AltRight,
+  MetaLeft: codeToIndex.MetaLeft,
+  MetaRight: codeToIndex.MetaRight,
+  // Navigation
+  Escape: codeToIndex.Escape,
+  Space: codeToIndex.Space,
+  Enter: codeToIndex.Enter,
+  Tab: codeToIndex.Tab,
+  Backspace: codeToIndex.Backspace,
+  Delete: codeToIndex.Delete,
+  ArrowLeft: codeToIndex.ArrowLeft,
+  ArrowUp: codeToIndex.ArrowUp,
+  ArrowRight: codeToIndex.ArrowRight,
+  ArrowDown: codeToIndex.ArrowDown,
+  Home: codeToIndex.Home,
+  End: codeToIndex.End,
+  PageUp: codeToIndex.PageUp,
+  PageDown: codeToIndex.PageDown,
+  Insert: codeToIndex.Insert,
+  // Punctuation
+  Semicolon: codeToIndex.Semicolon,
+  Equal: codeToIndex.Equal,
+  Comma: codeToIndex.Comma,
+  Minus: codeToIndex.Minus,
+  Period: codeToIndex.Period,
+  Slash: codeToIndex.Slash,
+  Backquote: codeToIndex.Backquote,
+  BracketLeft: codeToIndex.BracketLeft,
+  Backslash: codeToIndex.Backslash,
+  BracketRight: codeToIndex.BracketRight,
+  Quote: codeToIndex.Quote,
+  // Numpad
+  Numpad0: codeToIndex.Numpad0,
+  Numpad1: codeToIndex.Numpad1,
+  Numpad2: codeToIndex.Numpad2,
+  Numpad3: codeToIndex.Numpad3,
+  Numpad4: codeToIndex.Numpad4,
+  Numpad5: codeToIndex.Numpad5,
+  Numpad6: codeToIndex.Numpad6,
+  Numpad7: codeToIndex.Numpad7,
+  Numpad8: codeToIndex.Numpad8,
+  Numpad9: codeToIndex.Numpad9,
+  NumpadAdd: codeToIndex.NumpadAdd,
+  NumpadSubtract: codeToIndex.NumpadSubtract,
+  NumpadMultiply: codeToIndex.NumpadMultiply,
+  NumpadDivide: codeToIndex.NumpadDivide,
+  NumpadDecimal: codeToIndex.NumpadDecimal,
+  NumpadEnter: codeToIndex.NumpadEnter
+};
+
+// src/singletons/Mouse.ts
+var import_canvas_store26 = require("@woven-ecs/canvas-store");
+var import_core24 = require("@woven-ecs/core");
+var MouseSchema = {
+  /** Current mouse position relative to the editor element [x, y] */
+  position: import_core24.field.tuple(import_core24.field.float32(), 2).default([0, 0]),
+  /** Horizontal wheel delta (positive = scroll right) */
+  wheelDeltaX: import_core24.field.float32().default(0),
+  /** Vertical wheel delta (positive = scroll down), normalized across browsers */
+  wheelDeltaY: import_core24.field.float32().default(0),
+  /** True for 1 frame when mouse moves */
+  moveTrigger: import_core24.field.boolean().default(false),
+  /** True for 1 frame when wheel is scrolled */
+  wheelTrigger: import_core24.field.boolean().default(false),
+  /** True for 1 frame when mouse enters the editor element */
+  enterTrigger: import_core24.field.boolean().default(false),
+  /** True for 1 frame when mouse leaves the editor element */
+  leaveTrigger: import_core24.field.boolean().default(false)
+};
+var MouseDef = class extends import_canvas_store26.CanvasSingletonDef {
+  constructor() {
+    super({ name: "mouse" }, MouseSchema);
+  }
+  /** Check if mouse moved this frame */
+  didMove(ctx) {
+    return this.read(ctx).moveTrigger;
+  }
+  /** Check if wheel was scrolled this frame */
+  didScroll(ctx) {
+    return this.read(ctx).wheelTrigger;
+  }
+  /** Check if mouse entered the editor element this frame */
+  didEnter(ctx) {
+    return this.read(ctx).enterTrigger;
+  }
+  /** Check if mouse left the editor element this frame */
+  didLeave(ctx) {
+    return this.read(ctx).leaveTrigger;
+  }
+  /** Get current mouse position as [x, y] */
+  getPosition(ctx) {
+    const m = this.read(ctx);
+    return [m.position[0], m.position[1]];
+  }
+  /** Get wheel delta as [dx, dy] */
+  getWheelDelta(ctx) {
+    const m = this.read(ctx);
+    return [m.wheelDeltaX, m.wheelDeltaY];
+  }
+};
+var Mouse = new MouseDef();
+
+// src/singletons/RankBounds.ts
+var import_canvas_store27 = require("@woven-ecs/canvas-store");
+var import_core25 = require("@woven-ecs/core");
+var import_fractional_indexing_jittered = require("fractional-indexing-jittered");
+var RankBoundsSchema = {
+  minRank: import_core25.field.string().max(36).default(""),
+  maxRank: import_core25.field.string().max(36).default("")
+};
+var RankBoundsDef = class extends import_canvas_store27.CanvasSingletonDef {
+  constructor() {
+    super({ name: "rankBounds" }, RankBoundsSchema);
+  }
+  /**
+   * Generate the next rank (higher z-order than all existing).
+   * @returns A new rank string that sorts after maxRank
+   */
+  genNext(ctx) {
+    const bounds = this.write(ctx);
+    const next = (0, import_fractional_indexing_jittered.generateJitteredKeyBetween)(bounds.maxRank || null, null);
+    bounds.maxRank = next;
+    if (!bounds.minRank) {
+      bounds.minRank = next;
+    }
+    return next;
+  }
+  /**
+   * Generate the previous rank (lower z-order than all existing).
+   * @returns A new rank string that sorts before minRank
+   */
+  genPrev(ctx) {
+    const bounds = this.write(ctx);
+    const prev = (0, import_fractional_indexing_jittered.generateJitteredKeyBetween)(null, bounds.minRank || null);
+    bounds.minRank = prev;
+    if (!bounds.maxRank) {
+      bounds.maxRank = prev;
+    }
+    return prev;
+  }
+  /**
+   * Generate a rank between two existing ranks.
+   * @param before - Rank to come after (or null for start)
+   * @param after - Rank to come before (or null for end)
+   * @returns A new rank string that sorts between the two
+   */
+  genBetween(before, after) {
+    return (0, import_fractional_indexing_jittered.generateJitteredKeyBetween)(before, after);
+  }
+  /**
+   * Add a rank to tracking (expands bounds if needed).
+   */
+  add(ctx, rank) {
+    if (!rank) return;
+    const bounds = this.write(ctx);
+    if (!bounds.minRank || rank < bounds.minRank) {
+      bounds.minRank = rank;
+    }
+    if (!bounds.maxRank || rank > bounds.maxRank) {
+      bounds.maxRank = rank;
+    }
+  }
+};
+var RankBounds = new RankBoundsDef();
+
+// src/singletons/ScaleWithZoomState.ts
+var import_canvas_store28 = require("@woven-ecs/canvas-store");
+var import_core26 = require("@woven-ecs/core");
+var ScaleWithZoomState = (0, import_canvas_store28.defineCanvasSingleton)(
+  { name: "scaleWithZoomState" },
+  {
+    /** Last processed zoom level */
+    lastZoom: import_core26.field.float64().default(1)
+  }
+);
+
+// src/systems/capture/keybindSystem.ts
+var import_core29 = require("@woven-ecs/core");
+
+// src/command.ts
+var import_core27 = require("@woven-ecs/core");
+var CommandMarker = (0, import_core27.defineComponent)({
+  name: import_core27.field.string().max(128)
+});
+var editorPayloads = /* @__PURE__ */ new WeakMap();
+function getPayloadMap(ctx) {
+  const { editor } = (0, import_core27.getResources)(ctx);
+  let map = editorPayloads.get(editor);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    editorPayloads.set(editor, map);
+  }
+  return map;
+}
+var commands = (0, import_core27.defineQuery)((q) => q.with(CommandMarker));
+function defineCommand(name) {
+  return {
+    name,
+    spawn(ctx, payload) {
+      const eid = (0, import_core27.createEntity)(ctx);
+      (0, import_core27.addComponent)(ctx, eid, CommandMarker, { name });
+      getPayloadMap(ctx).set(eid, payload);
+      return eid;
+    },
+    *iter(ctx) {
+      const payloads = getPayloadMap(ctx);
+      for (const eid of commands.current(ctx)) {
+        const marker = CommandMarker.read(ctx, eid);
+        if (marker.name === name) {
+          const payload = payloads.get(eid);
+          yield { eid, payload };
+        }
+      }
+    },
+    didSpawnLastFrame(ctx) {
+      for (const eid of commands.removed(ctx)) {
+        const marker = CommandMarker.read(ctx, eid);
+        if (marker.name === name) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+}
+function cleanupCommands(ctx) {
+  const payloads = getPayloadMap(ctx);
+  for (const eid of commands.current(ctx)) {
+    payloads.delete(eid);
+    (0, import_core27.removeEntity)(ctx, eid);
+  }
+}
+function on(ctx, def, handler) {
+  for (const { payload } of def.iter(ctx)) {
+    handler(ctx, payload);
+  }
+}
+var Undo = defineCommand("undo");
+var Redo = defineCommand("redo");
+
+// src/EditorSystem.ts
+var import_core28 = require("@woven-ecs/core");
+var DEFAULT_PRIORITY = 0;
+function defineEditorSystem(options, execute) {
+  return {
+    _system: new import_core28.MainThreadSystem(execute),
+    phase: options.phase,
+    priority: options.priority ?? DEFAULT_PRIORITY
+  };
+}
+
+// src/systems/capture/keybindSystem.ts
+var keybindSystem = defineEditorSystem({ phase: "capture" }, (ctx) => {
+  const keyboard = Keyboard.read(ctx);
+  const { editor } = (0, import_core29.getResources)(ctx);
+  for (const keybind of editor.keybinds) {
+    let triggered = Keyboard.isKeyDownTrigger(ctx, keybind.key);
+    triggered &&= !!keybind.mod === keyboard.modDown;
+    triggered &&= !!keybind.shift === keyboard.shiftDown;
+    if (triggered) {
+      const eid = (0, import_core29.createEntity)(ctx);
+      (0, import_core29.addComponent)(ctx, eid, CommandMarker, { name: keybind.command });
+      break;
+    }
+  }
+});
+
+// src/systems/input/frameSystem.ts
+var frameSystem = defineEditorSystem({ phase: "input", priority: 100 }, (ctx) => {
+  const now = performance.now();
+  const buffer = Frame._getInstance(ctx).buffer;
+  const last = buffer.lastTime[0];
+  buffer.number[0]++;
+  buffer.lastTime[0] = now;
+  buffer.time[0] = now;
+  if (last === 0) {
+    buffer.delta[0] = 0.016;
+  } else {
+    buffer.delta[0] = Math.min((now - last) / 1e3, 0.1);
+  }
+});
+
+// src/systems/input/keyboardSystem.ts
+var import_core30 = require("@woven-ecs/core");
+var instanceState = /* @__PURE__ */ new WeakMap();
+function attachKeyboardListeners(domElement) {
+  if (instanceState.has(domElement)) return;
+  if (!domElement.hasAttribute("tabindex")) {
+    domElement.setAttribute("tabindex", "0");
+  }
+  const state = {
+    eventsBuffer: [],
+    onKeyDown: (e) => {
+      if (e.key === "Tab" || e.key === "Alt" || e.key === " ") {
+        e.preventDefault();
+      }
+      state.eventsBuffer.push(e);
+    },
+    onKeyUp: (e) => {
+      state.eventsBuffer.push(e);
+    },
+    onBlur: () => {
+      state.eventsBuffer.push({ type: "blur" });
+    },
+    // Reusable buffers - allocated once per instance
+    keysDown: new Uint8Array(32),
+    keysDownTrigger: new Uint8Array(32),
+    keysUpTrigger: new Uint8Array(32)
+  };
+  instanceState.set(domElement, state);
+  domElement.addEventListener("keydown", state.onKeyDown);
+  domElement.addEventListener("keyup", state.onKeyUp);
+  domElement.addEventListener("blur", state.onBlur);
+}
+function detachKeyboardListeners(domElement) {
+  const state = instanceState.get(domElement);
+  if (!state) return;
+  domElement.removeEventListener("keydown", state.onKeyDown);
+  domElement.removeEventListener("keyup", state.onKeyUp);
+  domElement.removeEventListener("blur", state.onBlur);
+  instanceState.delete(domElement);
+}
+var keyboardSystem = defineEditorSystem({ phase: "input" }, (ctx) => {
+  const resources = (0, import_core30.getResources)(ctx);
+  const state = instanceState.get(resources.domElement);
+  if (!state) return;
+  const hasEvents = state.eventsBuffer.length > 0;
+  const triggersNeedClearing = !isZeroed(state.keysDownTrigger) || !isZeroed(state.keysUpTrigger);
+  if (!hasEvents && !triggersNeedClearing) return;
+  const keyboard = Keyboard.write(ctx);
+  const keysDown = state.keysDown;
+  const keysDownTrigger = state.keysDownTrigger;
+  const keysUpTrigger = state.keysUpTrigger;
+  keysDownTrigger.fill(0);
+  keysUpTrigger.fill(0);
+  keysDown.set(keyboard.keysDown);
+  for (const event of state.eventsBuffer) {
+    if (event.type === "blur") {
+      keysDown.fill(0);
+      keyboard.shiftDown = false;
+      keyboard.altDown = false;
+      keyboard.modDown = false;
+      continue;
+    }
+    const keyIndex = codeToIndex[event.code];
+    if (keyIndex === void 0) continue;
+    if (event.type === "keydown") {
+      const wasDown = getBit2(keysDown, keyIndex);
+      if (!wasDown) {
+        setBit(keysDownTrigger, keyIndex, true);
+      }
+      setBit(keysDown, keyIndex, true);
+    } else if (event.type === "keyup") {
+      setBit(keysDown, keyIndex, false);
+      setBit(keysUpTrigger, keyIndex, true);
+    }
+    keyboard.shiftDown = event.shiftKey;
+    keyboard.altDown = event.altKey;
+    keyboard.modDown = event.ctrlKey || event.metaKey;
+  }
+  keyboard.keysDown = keysDown;
+  keyboard.keysDownTrigger = keysDownTrigger;
+  keyboard.keysUpTrigger = keysUpTrigger;
+  state.eventsBuffer.length = 0;
+});
+function getBit2(buffer, bitIndex) {
+  if (bitIndex < 0 || bitIndex >= buffer.length * 8) return false;
+  const byteIndex = Math.floor(bitIndex / 8);
+  const bitOffset = bitIndex % 8;
+  return (buffer[byteIndex] & 1 << bitOffset) !== 0;
+}
+function isZeroed(buffer) {
+  for (let i = 0; i < buffer.length; i++) {
+    if (buffer[i] !== 0) return false;
+  }
+  return true;
+}
+
+// src/systems/input/mouseSystem.ts
+var import_core31 = require("@woven-ecs/core");
+var instanceState2 = /* @__PURE__ */ new WeakMap();
+function attachMouseListeners(domElement) {
+  if (instanceState2.has(domElement)) return;
+  const state = {
+    eventsBuffer: [],
+    onMouseMove: (e) => {
+      state.eventsBuffer.push({
+        type: "mousemove",
+        clientX: e.clientX,
+        clientY: e.clientY
+      });
+    },
+    onWheel: (e) => {
+      e.preventDefault();
+      state.eventsBuffer.push({
+        type: "wheel",
+        clientX: e.clientX,
+        clientY: e.clientY,
+        deltaX: e.deltaX,
+        deltaY: e.deltaY,
+        deltaMode: e.deltaMode
+      });
+    },
+    onMouseEnter: () => {
+      state.eventsBuffer.push({ type: "mouseenter" });
+    },
+    onMouseLeave: () => {
+      state.eventsBuffer.push({ type: "mouseleave" });
+    }
+  };
+  instanceState2.set(domElement, state);
+  window.addEventListener("mousemove", state.onMouseMove);
+  domElement.addEventListener("wheel", state.onWheel, { passive: false });
+  domElement.addEventListener("mouseenter", state.onMouseEnter);
+  domElement.addEventListener("mouseleave", state.onMouseLeave);
+}
+function detachMouseListeners(domElement) {
+  const state = instanceState2.get(domElement);
+  if (!state) return;
+  window.removeEventListener("mousemove", state.onMouseMove);
+  domElement.removeEventListener("wheel", state.onWheel);
+  domElement.removeEventListener("mouseenter", state.onMouseEnter);
+  domElement.removeEventListener("mouseleave", state.onMouseLeave);
+  instanceState2.delete(domElement);
+}
+var mouseSystem = defineEditorSystem({ phase: "input" }, (ctx) => {
+  const resources = (0, import_core31.getResources)(ctx);
+  const state = instanceState2.get(resources.domElement);
+  if (!state) return;
+  const currentMouse = Mouse.read(ctx);
+  const hadTriggers = currentMouse.moveTrigger || currentMouse.wheelTrigger || currentMouse.enterTrigger || currentMouse.leaveTrigger;
+  const hasEvents = state.eventsBuffer.length > 0;
+  if (!hadTriggers && !hasEvents) return;
+  const mouse = Mouse.write(ctx);
+  const screen = Screen.read(ctx);
+  mouse.moveTrigger = false;
+  mouse.wheelTrigger = false;
+  mouse.enterTrigger = false;
+  mouse.leaveTrigger = false;
+  mouse.wheelDeltaX = 0;
+  mouse.wheelDeltaY = 0;
+  for (const event of state.eventsBuffer) {
+    switch (event.type) {
+      case "mousemove":
+        mouse.position = [event.clientX - screen.left, event.clientY - screen.top];
+        mouse.moveTrigger = true;
+        break;
+      case "wheel":
+        mouse.wheelDeltaX = event.deltaX;
+        mouse.wheelDeltaY = normalizeWheelDelta(event.deltaY, event.deltaMode);
+        mouse.wheelTrigger = true;
+        break;
+      case "mouseenter":
+        mouse.enterTrigger = true;
+        break;
+      case "mouseleave":
+        mouse.leaveTrigger = true;
+        break;
+    }
+  }
+  state.eventsBuffer.length = 0;
+});
+function normalizeWheelDelta(deltaY, deltaMode) {
+  const LINE_HEIGHT = 16;
+  const PAGE_HEIGHT = typeof window !== "undefined" ? window.innerHeight : 800;
+  let normalized = deltaY;
+  if (deltaMode === 1) {
+    normalized *= LINE_HEIGHT;
+  } else if (deltaMode === 2) {
+    normalized *= PAGE_HEIGHT;
+  }
+  if (typeof navigator !== "undefined" && navigator.userAgent.includes("Firefox")) {
+    normalized *= 4;
+  }
+  if (typeof navigator !== "undefined" && (navigator.userAgent.includes("Mac") || navigator.userAgent.includes("Macintosh"))) {
+    normalized *= 1.5;
+  }
+  return Math.min(Math.max(normalized, -100), 100);
+}
+
+// src/systems/input/pointerSystem.ts
+var import_core32 = require("@woven-ecs/core");
+var instanceState3 = /* @__PURE__ */ new WeakMap();
+function attachPointerListeners(domElement) {
+  if (instanceState3.has(domElement)) return;
+  const state = {
+    eventsBuffer: [],
+    frameCount: 0,
+    pointerEntityMap: /* @__PURE__ */ new Map(),
+    onPointerDown: (e) => {
+      state.eventsBuffer.push({
+        type: "pointerdown",
+        pointerId: e.pointerId,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        button: e.button,
+        pointerType: e.pointerType,
+        pressure: e.pressure,
+        target: e.target
+      });
+    },
+    onContextMenu: (e) => {
+      e.preventDefault();
+      const hasPointerDown = state.eventsBuffer.some((evt) => evt.type === "pointerdown");
+      if (hasPointerDown) return;
+      state.eventsBuffer.push({
+        type: "pointerdown",
+        pointerId: 0,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        button: 2,
+        // Right button
+        pointerType: "mouse",
+        pressure: 0.5,
+        target: e.target
+      });
+    },
+    onPointerMove: (e) => {
+      state.eventsBuffer.push({
+        type: "pointermove",
+        pointerId: e.pointerId,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        button: e.button,
+        pointerType: e.pointerType,
+        pressure: e.pressure,
+        target: e.target
+      });
+    },
+    onPointerUp: (e) => {
+      state.eventsBuffer.push({
+        type: "pointerup",
+        pointerId: e.pointerId,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        button: e.button,
+        pointerType: e.pointerType,
+        pressure: e.pressure,
+        target: e.target
+      });
+    },
+    onPointerCancel: (e) => {
+      state.eventsBuffer.push({
+        type: "pointercancel",
+        pointerId: e.pointerId,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        button: e.button,
+        pointerType: e.pointerType,
+        pressure: e.pressure,
+        target: e.target
+      });
+    }
+  };
+  instanceState3.set(domElement, state);
+  domElement.addEventListener("pointerdown", state.onPointerDown);
+  domElement.addEventListener("contextmenu", state.onContextMenu);
+  window.addEventListener("pointermove", state.onPointerMove);
+  window.addEventListener("pointerup", state.onPointerUp);
+  window.addEventListener("pointercancel", state.onPointerCancel);
+}
+function detachPointerListeners(domElement) {
+  const state = instanceState3.get(domElement);
+  if (!state) return;
+  domElement.removeEventListener("pointerdown", state.onPointerDown);
+  domElement.removeEventListener("contextmenu", state.onContextMenu);
+  window.removeEventListener("pointermove", state.onPointerMove);
+  window.removeEventListener("pointerup", state.onPointerUp);
+  window.removeEventListener("pointercancel", state.onPointerCancel);
+  instanceState3.delete(domElement);
+}
+var pointerSystem = defineEditorSystem({ phase: "input" }, (ctx) => {
+  const resources = (0, import_core32.getResources)(ctx);
+  const { domElement } = resources;
+  const state = instanceState3.get(domElement);
+  if (!state) return;
+  state.frameCount++;
+  const screen = Screen.read(ctx);
+  const time = state.frameCount / 60;
+  for (const event of state.eventsBuffer) {
+    switch (event.type) {
+      case "pointerdown": {
+        const position = [event.clientX - screen.left, event.clientY - screen.top];
+        const entityId = (0, import_core32.createEntity)(ctx);
+        (0, import_core32.addComponent)(ctx, entityId, Pointer, {
+          pointerId: event.pointerId,
+          position,
+          downPosition: position,
+          downFrame: state.frameCount,
+          button: Pointer.getButton(event.button),
+          pointerType: Pointer.getType(event.pointerType),
+          pressure: event.pressure,
+          obscured: event.target !== domElement
+        });
+        const pointer = Pointer.write(ctx, entityId);
+        addPointerSample(pointer, position, time);
+        state.pointerEntityMap.set(event.pointerId, entityId);
+        break;
+      }
+      case "pointermove": {
+        const entityId = state.pointerEntityMap.get(event.pointerId);
+        if (entityId === void 0) break;
+        const position = [event.clientX - screen.left, event.clientY - screen.top];
+        const pointer = Pointer.write(ctx, entityId);
+        addPointerSample(pointer, position, time);
+        pointer.pressure = event.pressure;
+        pointer.obscured = event.target !== domElement;
+        break;
+      }
+      case "pointerup":
+      case "pointercancel": {
+        const entityId = state.pointerEntityMap.get(event.pointerId);
+        if (entityId === void 0) break;
+        const position = [event.clientX - screen.left, event.clientY - screen.top];
+        const pointer = Pointer.write(ctx, entityId);
+        addPointerSample(pointer, position, time);
+        (0, import_core32.removeEntity)(ctx, entityId);
+        state.pointerEntityMap.delete(event.pointerId);
+        break;
+      }
+    }
+  }
+  state.eventsBuffer.length = 0;
+});
+
+// src/systems/input/screenSystem.ts
+var import_core33 = require("@woven-ecs/core");
+var instanceState4 = /* @__PURE__ */ new WeakMap();
+function attachScreenObserver(domElement) {
+  if (instanceState4.has(domElement)) return;
+  const state = {
+    needsUpdate: false,
+    resizeObserver: new ResizeObserver(() => {
+      state.needsUpdate = true;
+    }),
+    onScroll: () => {
+      state.needsUpdate = true;
+    }
+  };
+  instanceState4.set(domElement, state);
+  state.resizeObserver.observe(domElement);
+  window.addEventListener("scroll", state.onScroll, true);
+}
+function detachScreenObserver(domElement) {
+  const state = instanceState4.get(domElement);
+  if (!state) return;
+  state.resizeObserver.disconnect();
+  window.removeEventListener("scroll", state.onScroll, true);
+  instanceState4.delete(domElement);
+}
+var screenSystem = defineEditorSystem({ phase: "input" }, (ctx) => {
+  const resources = (0, import_core33.getResources)(ctx);
+  const { domElement } = resources;
+  const state = instanceState4.get(domElement);
+  if (!state) return;
+  const frame = Frame.read(ctx);
+  if (frame.number === 1) {
+    state.needsUpdate = true;
+  }
+  if (!state.needsUpdate) return;
+  const screen = Screen.write(ctx);
+  const rect = domElement.getBoundingClientRect();
+  screen.left = rect.left;
+  screen.top = rect.top;
+  screen.width = rect.width;
+  screen.height = rect.height;
+  state.needsUpdate = false;
+});
+
+// src/systems/postRender/cursorSystem.ts
+var import_core34 = require("@woven-ecs/core");
+var cursorQuery = (0, import_core34.defineQuery)((q) => q.tracking(Cursor));
+function getCursorSvg(cursors, kind, rotateZ) {
+  const def = cursors[kind];
+  if (!def) return "auto";
+  const svg = def.makeSvg(rotateZ + def.rotationOffset);
+  return `url("data:image/svg+xml,${encodeURIComponent(svg.trim())}") ${def.hotspot[0]} ${def.hotspot[1]}, auto`;
+}
+var cursorSystem = defineEditorSystem({ phase: "render", priority: -100 }, (ctx) => {
+  const changedCursors = cursorQuery.changed(ctx);
+  const frame = Frame.read(ctx);
+  if (changedCursors.length === 0 && frame.number !== 1) {
+    return;
+  }
+  const { cursorKind, rotation } = Cursor.getEffective(ctx);
+  if (!cursorKind) {
+    document.body.style.cursor = "default";
+    return;
+  }
+  const { editor } = (0, import_core34.getResources)(ctx);
+  const cursorValue = getCursorSvg(editor.cursors, cursorKind, rotation);
+  document.body.style.cursor = cursorValue;
+});
+
+// src/systems/postRender/presenceSystem.ts
+var import_core41 = require("@woven-ecs/core");
+
+// src/helpers/blockDefs.ts
+var import_core35 = require("@woven-ecs/core");
+function getBlockDefs(ctx) {
+  const { editor } = (0, import_core35.getResources)(ctx);
+  return editor.blockDefs;
+}
+function getBlockDef(ctx, tag) {
+  const blockDefs = getBlockDefs(ctx);
+  return blockDefs[tag] ?? BlockDef2.parse({ tag });
+}
+function canBlockEdit(ctx, tag) {
+  return getBlockDef(ctx, tag).editOptions.canEdit;
+}
+
+// src/helpers/computeAabb.ts
+var import_math4 = require("@woven-canvas/math");
+var import_core36 = require("@woven-ecs/core");
+function computeAabb(ctx, entityId, out) {
+  if ((0, import_core36.hasComponent)(ctx, entityId, HitGeometry)) {
+    const pts = HitGeometry.getExtremaWorld(ctx, entityId);
+    import_math4.Aabb.setFromPoints(out, pts);
+  } else {
+    const corners = Block.getCorners(ctx, entityId);
+    import_math4.Aabb.setFromPoints(out, corners);
+  }
+}
+
+// src/helpers/held.ts
+var import_core37 = require("@woven-ecs/core");
+function isHeldByRemote(ctx, entityId) {
+  if (!(0, import_core37.hasComponent)(ctx, entityId, Held)) return false;
+  const { sessionId } = (0, import_core37.getResources)(ctx);
+  const held = Held.read(ctx, entityId);
+  return held.sessionId !== "" && held.sessionId !== sessionId;
+}
+
+// src/helpers/intersect.ts
+var import_math5 = require("@woven-canvas/math");
+var import_core38 = require("@woven-ecs/core");
+var blocksWithAabb = (0, import_core38.defineQuery)((q) => q.with(Block, Aabb));
+function intersectPoint(ctx, point, entityIds) {
+  const intersects = [];
+  const entities = entityIds ?? blocksWithAabb.current(ctx);
+  for (const entityId of entities) {
+    if (!Aabb.containsPoint(ctx, entityId, point)) {
+      continue;
+    }
+    if ((0, import_core38.hasComponent)(ctx, entityId, HitGeometry)) {
+      if (!HitGeometry.containsPointWorld(ctx, entityId, point)) {
+        continue;
+      }
+    } else {
+      if (!Block.containsPoint(ctx, entityId, point)) {
+        continue;
+      }
+    }
+    intersects.push(entityId);
+  }
+  return sortByRankDescending(ctx, intersects);
+}
+function intersectAabb(ctx, bounds, entityIds) {
+  const intersecting = [];
+  const entities = entityIds ?? blocksWithAabb.current(ctx);
+  for (const entityId of entities) {
+    const { value: entityAabb } = Aabb.read(ctx, entityId);
+    if (!import_math5.Aabb.intersects(bounds, entityAabb)) {
+      continue;
+    }
+    if (import_math5.Aabb.contains(bounds, entityAabb)) {
+      intersecting.push(entityId);
+      continue;
+    }
+    if ((0, import_core38.hasComponent)(ctx, entityId, HitGeometry)) {
+      if (HitGeometry.intersectsAabbWorld(ctx, entityId, bounds)) {
+        intersecting.push(entityId);
+      }
+    } else {
+      if (Block.intersectsAabb(ctx, entityId, bounds)) {
+        intersecting.push(entityId);
+      }
+    }
+  }
+  return intersecting;
+}
+function sortByRankDescending(ctx, entityIds) {
+  return entityIds.sort((a, b) => {
+    const blockA = Block.read(ctx, a);
+    const blockB = Block.read(ctx, b);
+    const stratumA = getBlockDef(ctx, blockA.tag).stratum;
+    const stratumB = getBlockDef(ctx, blockB.tag).stratum;
+    const stratumOrderA = STRATUM_ORDER[stratumA];
+    const stratumOrderB = STRATUM_ORDER[stratumB];
+    if (stratumOrderB !== stratumOrderA) {
+      return stratumOrderB - stratumOrderA;
+    }
+    const rankA = blockA.rank;
+    const rankB = blockB.rank;
+    if (!rankA && !rankB) return 0;
+    if (!rankA) return 1;
+    if (!rankB) return -1;
+    if (rankB > rankA) return 1;
+    if (rankB < rankA) return -1;
+    return 0;
+  });
+}
+function getTopmostBlockAtPoint(ctx, point) {
+  const intersects = intersectPoint(ctx, point);
+  return intersects[0];
+}
+
+// src/helpers/intersectCapsule.ts
+var import_math6 = require("@woven-canvas/math");
+var import_core39 = require("@woven-ecs/core");
+var _uvToWorldMatrix2 = [1, 0, 0, 1, 0, 0];
+function intersectCapsule(ctx, capsule, entityIds) {
+  const intersects = [];
+  const capsuleBounds = import_math6.Capsule.bounds(capsule);
+  for (const entityId of entityIds) {
+    const aabb = Aabb.read(ctx, entityId);
+    if (!import_math6.Aabb.intersects(capsuleBounds, aabb.value)) {
+      continue;
+    }
+    if ((0, import_core39.hasComponent)(ctx, entityId, HitGeometry)) {
+      if (intersectsCapsuleHitGeometry(ctx, entityId, capsule)) {
+        intersects.push(entityId);
+      }
+    } else {
+      if (import_math6.Capsule.intersectsAabb(capsule, aabb.value)) {
+        intersects.push(entityId);
+      }
+    }
+  }
+  return intersects;
+}
+function intersectsCapsuleHitGeometry(ctx, entityId, capsule) {
+  const hitGeometry = HitGeometry.read(ctx, entityId);
+  Block.getUvToWorldMatrix(ctx, entityId, _uvToWorldMatrix2);
+  for (let i = 0; i < hitGeometry.arcCount; i++) {
+    const uvArc = HitGeometry.getArcAt(ctx, entityId, i);
+    const worldA = [uvArc[0], uvArc[1]];
+    import_math6.Mat2.transformPoint(_uvToWorldMatrix2, worldA);
+    const worldB = [uvArc[2], uvArc[3]];
+    import_math6.Mat2.transformPoint(_uvToWorldMatrix2, worldB);
+    const worldC = [uvArc[4], uvArc[5]];
+    import_math6.Mat2.transformPoint(_uvToWorldMatrix2, worldC);
+    const thickness = uvArc[6];
+    const worldArc = import_math6.Arc.create(worldA[0], worldA[1], worldB[0], worldB[1], worldC[0], worldC[1], thickness);
+    const capsuleA = import_math6.Capsule.pointA(capsule);
+    const capsuleB = import_math6.Capsule.pointB(capsule);
+    if (import_math6.Arc.intersectsCapsule(worldArc, capsuleA, capsuleB, import_math6.Capsule.radius(capsule))) {
+      return true;
+    }
+  }
+  for (let i = 0; i < hitGeometry.capsuleCount; i++) {
+    const uvCapsule = HitGeometry.getCapsuleAt(ctx, entityId, i);
+    const worldA = [uvCapsule[0], uvCapsule[1]];
+    import_math6.Mat2.transformPoint(_uvToWorldMatrix2, worldA);
+    const worldB = [uvCapsule[2], uvCapsule[3]];
+    import_math6.Mat2.transformPoint(_uvToWorldMatrix2, worldB);
+    const radius = uvCapsule[4];
+    const worldCapsule = import_math6.Capsule.create(worldA[0], worldA[1], worldB[0], worldB[1], radius);
+    if (import_math6.Capsule.intersectsCapsule(capsule, worldCapsule)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/helpers/user.ts
+var import_core40 = require("@woven-ecs/core");
+var userQuery = (0, import_core40.defineQuery)((q) => q.with(User));
+function getMyUserEntityId(ctx) {
+  const mySessionId = (0, import_core40.getResources)(ctx).sessionId;
+  for (const eid of userQuery.current(ctx)) {
+    const user = User.read(ctx, eid);
+    if (user.sessionId === mySessionId) {
+      return eid;
+    }
+  }
+  return null;
+}
+
+// src/systems/postRender/presenceSystem.ts
+var pointerQuery = (0, import_core41.defineQuery)((q) => q.tracking(Pointer));
+var presenceSystem = defineEditorSystem({ phase: "render", priority: -100 }, (ctx) => {
+  if (Mouse.didMove(ctx)) {
+    const mouse = Mouse.read(ctx);
+    updateUserPosition(ctx, mouse.position);
+    return;
+  }
+  const changedPointers = pointerQuery.changed(ctx);
+  if (changedPointers.length === 0) return;
+  const pointers = pointerQuery.current(ctx);
+  let mainPointerEid = null;
+  let lowestId = Number.MAX_SAFE_INTEGER;
+  for (const eid of pointers) {
+    const pointer2 = Pointer.read(ctx, eid);
+    if (pointer2.pointerId < lowestId) {
+      lowestId = pointer2.pointerId;
+      mainPointerEid = eid;
+    }
+  }
+  const pointer = Pointer.read(ctx, mainPointerEid);
+  updateUserPosition(ctx, pointer.position);
+});
+function updateUserPosition(ctx, position) {
+  const myUserEid = getMyUserEntityId(ctx);
+  if (myUserEid === null) return;
+  const user = User.write(ctx, myUserEid);
+  user.position = Camera.toWorld(ctx, position);
+}
+
+// src/systems/preCapture/intersectSystem.ts
+var import_core42 = require("@woven-ecs/core");
+var blocksChanged = (0, import_core42.defineQuery)((q) => q.tracking(Block));
+var hitGeometryChanged = (0, import_core42.defineQuery)((q) => q.tracking(HitGeometry));
+var heldQuery = (0, import_core42.defineQuery)((q) => q.with(Held).tracking(Held));
+var hoveredQuery = (0, import_core42.defineQuery)((q) => q.with(Hovered));
+var pointerQuery2 = (0, import_core42.defineQuery)((q) => q.with(Pointer));
+function clearHovered(ctx) {
+  for (const entityId of hoveredQuery.current(ctx)) {
+    if ((0, import_core42.hasComponent)(ctx, entityId, Hovered)) {
+      (0, import_core42.removeComponent)(ctx, entityId, Hovered);
+    }
+  }
+}
+function findValidHoverTarget(ctx, intersected) {
+  for (const entityId of intersected) {
+    if (isHeldByRemote(ctx, entityId)) return void 0;
+    return entityId;
+  }
+  return void 0;
+}
+function updateHovered(ctx, intersected) {
+  const controls = Controls.read(ctx);
+  const selectToolActive = controls.leftMouseTool === "select";
+  clearHovered(ctx);
+  if (!selectToolActive) return;
+  const newHoveredId = findValidHoverTarget(ctx, intersected);
+  if (newHoveredId !== void 0) {
+    (0, import_core42.addComponent)(ctx, newHoveredId, Hovered, {});
+  }
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+var added = /* @__PURE__ */ new Set();
+var changed = /* @__PURE__ */ new Set();
+var intersectSystem = defineEditorSystem({ phase: "capture", priority: 100 }, (ctx) => {
+  added.clear();
+  for (const entityId of blocksChanged.added(ctx)) {
+    added.add(entityId);
+  }
+  for (const entityId of hitGeometryChanged.added(ctx)) {
+    added.add(entityId);
+  }
+  changed.clear();
+  for (const entityId of blocksChanged.changed(ctx)) {
+    changed.add(entityId);
+  }
+  for (const entityId of hitGeometryChanged.changed(ctx)) {
+    changed.add(entityId);
+  }
+  for (const entityId of added) {
+    if (!(0, import_core42.hasComponent)(ctx, entityId, Aabb)) {
+      (0, import_core42.addComponent)(ctx, entityId, Aabb, { value: [0, 0, 0, 0] });
+    }
+    const aabb = Aabb.write(ctx, entityId);
+    computeAabb(ctx, entityId, aabb.value);
+  }
+  for (const entityId of changed) {
+    const aabb = Aabb.write(ctx, entityId);
+    computeAabb(ctx, entityId, aabb.value);
+  }
+  const mouseDidMove = Mouse.didMove(ctx);
+  const mouseDidLeave = Mouse.didLeave(ctx);
+  const mouseDidScroll = Mouse.didScroll(ctx);
+  const blocksHaveChanged = added.size > 0 || changed.size > 0;
+  const heldAdded = heldQuery.added(ctx);
+  const heldRemoved = heldQuery.removed(ctx);
+  const heldChanged = heldAdded.length > 0 || heldRemoved.length > 0;
+  if (!mouseDidMove && !mouseDidLeave && !mouseDidScroll && !blocksHaveChanged && !heldChanged) {
+    return;
+  }
+  if (mouseDidLeave) {
+    Intersect.clear(ctx);
+    clearHovered(ctx);
+    return;
+  }
+  const mousePos = Mouse.getPosition(ctx);
+  const worldPos = Camera.toWorld(ctx, mousePos);
+  const intersected = intersectPoint(ctx, worldPos);
+  const prevIntersected = Intersect.getAll(ctx);
+  const intersectsChanged = !arraysEqual(intersected, prevIntersected);
+  if (intersectsChanged) {
+    Intersect.setAll(ctx, intersected);
+  }
+  const pointers = pointerQuery2.current(ctx);
+  if (pointers.length > 0) {
+    return;
+  }
+  if (intersectsChanged || heldChanged) {
+    updateHovered(ctx, intersected);
+  }
+});
+
+// src/systems/preInput/rankBoundsSystem.ts
+var import_canvas_store29 = require("@woven-ecs/canvas-store");
+var import_core43 = require("@woven-ecs/core");
+var blocksQuery = (0, import_core43.defineQuery)((q) => q.with(import_canvas_store29.Synced, Block));
+var rankBoundsSystem = defineEditorSystem({ phase: "input", priority: 100 }, (ctx) => {
+  const added2 = blocksQuery.added(ctx);
+  for (const entityId of added2) {
+    const block = Block.read(ctx, entityId);
+    if (block.rank === "") {
+      const writableBlock = Block.write(ctx, entityId);
+      writableBlock.rank = RankBounds.genNext(ctx);
+    } else {
+      RankBounds.add(ctx, block.rank);
+    }
+  }
+});
+
+// src/systems/preRender/canSeeBlocksSystem.ts
+var import_math7 = require("@woven-canvas/math");
+var import_canvas_store30 = require("@woven-ecs/canvas-store");
+var import_core44 = require("@woven-ecs/core");
+var camerasQuery = (0, import_core44.defineQuery)((q) => q.tracking(Camera));
+var blocksQuery2 = (0, import_core44.defineQuery)((q) => q.with(import_canvas_store30.Synced, Block, Aabb));
+var syncedBlocksQuery = (0, import_core44.defineQuery)((q) => q.with(import_canvas_store30.Synced, Block, Aabb));
+var _cameraAabb = [0, 0, 0, 0];
+var canSeeBlocksSystem = defineEditorSystem({ phase: "render", priority: 90 }, (ctx) => {
+  if (camerasQuery.changed(ctx).length === 0 && syncedBlocksQuery.addedOrRemoved(ctx).length === 0) {
+    return;
+  }
+  const camera = Camera.read(ctx);
+  const cameraAabb = Camera.getAabb(ctx, _cameraAabb);
+  if (camera.canSeeBlocks && camera.lastSeenBlock !== null) {
+    if ((0, import_core44.hasComponent)(ctx, camera.lastSeenBlock, Aabb)) {
+      const aabb = Aabb.read(ctx, camera.lastSeenBlock);
+      if (import_math7.Aabb.intersects(cameraAabb, aabb.value)) {
+        return;
+      }
+    }
+  }
+  let seenBlock = null;
+  for (const entityId of blocksQuery2.current(ctx)) {
+    const aabb = Aabb.read(ctx, entityId);
+    if (import_math7.Aabb.intersects(cameraAabb, aabb.value)) {
+      seenBlock = entityId;
+      break;
+    }
+  }
+  const canSeeBlocks = seenBlock !== null;
+  if (canSeeBlocks === camera.canSeeBlocks) {
+    if (seenBlock !== camera.lastSeenBlock) {
+      Camera.write(ctx).lastSeenBlock = seenBlock;
+    }
+    return;
+  }
+  const writableCamera = Camera.write(ctx);
+  writableCamera.canSeeBlocks = canSeeBlocks;
+  writableCamera.lastSeenBlock = seenBlock;
+});
+
+// src/systems/preRender/scaleWithZoomSystem.ts
+var import_math8 = require("@woven-canvas/math");
+var import_core45 = require("@woven-ecs/core");
+var scaleWithZoomQuery = (0, import_core45.defineQuery)((q) => q.with(Block).tracking(ScaleWithZoom));
+var _scaledSize = [0, 0];
+var _anchorOffset = [0, 0];
+var scaleWithZoomSystem = defineEditorSystem({ phase: "render", priority: 100 }, (ctx) => {
+  const camera = Camera.read(ctx);
+  const state = ScaleWithZoomState.read(ctx);
+  const zoomChanged = !import_math8.Scalar.approxEqual(camera.zoom, state.lastZoom);
+  if (zoomChanged) {
+    for (const entityId of scaleWithZoomQuery.current(ctx)) {
+      scaleBlock(ctx, entityId, camera.zoom);
+    }
+    ScaleWithZoomState.write(ctx).lastZoom = camera.zoom;
+  }
+  for (const entityId of scaleWithZoomQuery.addedOrChanged(ctx)) {
+    scaleBlock(ctx, entityId, camera.zoom);
+  }
+});
+function scaleBlock(ctx, entityId, zoom) {
+  const block = Block.write(ctx, entityId);
+  const swz = ScaleWithZoom.read(ctx, entityId);
+  const baseScale = 1 / zoom;
+  const scaleX = 1 + (baseScale - 1) * swz.scaleMultiplier[0];
+  const scaleY = 1 + (baseScale - 1) * swz.scaleMultiplier[1];
+  _scaledSize[0] = swz.startSize[0] * scaleX;
+  _scaledSize[1] = swz.startSize[1] * scaleY;
+  import_math8.Vec2.copy(_anchorOffset, swz.startSize);
+  import_math8.Vec2.sub(_anchorOffset, _scaledSize);
+  import_math8.Vec2.multiply(_anchorOffset, swz.anchor);
+  import_math8.Vec2.copy(block.position, swz.startPosition);
+  import_math8.Vec2.add(block.position, _anchorOffset);
+  import_math8.Vec2.copy(block.size, _scaledSize);
+}
+
+// src/CorePlugin.ts
+var CorePlugin = {
+  name: PLUGIN_NAME,
+  singletons: Object.values(singletons_exports).filter((v) => v instanceof import_canvas_store31.CanvasSingletonDef),
+  components: Object.values(components_exports).filter((v) => v instanceof import_canvas_store31.CanvasComponentDef),
+  blockDefs: [
+    {
+      tag: "sticky-note",
+      components: [Color, Text, VerticalAlign],
+      editOptions: {
+        canEdit: true
+      }
+    },
+    {
+      tag: "text",
+      components: [Text],
+      resizeMode: "text",
+      editOptions: {
+        canEdit: true,
+        removeWhenTextEmpty: true
+      }
+    },
+    {
+      tag: "image",
+      components: [Image, Asset],
+      resizeMode: "scale"
+    },
+    {
+      tag: "shape",
+      components: [Shape, Text, VerticalAlign],
+      resizeMode: "free",
+      editOptions: {
+        canEdit: true
+      }
+    }
+  ],
+  systems: [
+    // Input phase
+    frameSystem,
+    // priority: 100
+    rankBoundsSystem,
+    // priority: 100
+    keyboardSystem,
+    mouseSystem,
+    screenSystem,
+    pointerSystem,
+    // Capture phase
+    intersectSystem,
+    // priority: 100
+    keybindSystem,
+    // Render phase
+    scaleWithZoomSystem,
+    // priority: 100
+    canSeeBlocksSystem,
+    // priority: 90
+    cursorSystem,
+    // priority: -100
+    presenceSystem
+    // priority: -100
+  ],
+  setup(ctx) {
+    const { domElement } = (0, import_core46.getResources)(ctx);
+    attachKeyboardListeners(domElement);
+    attachMouseListeners(domElement);
+    attachScreenObserver(domElement);
+    attachPointerListeners(domElement);
+  },
+  teardown(ctx) {
+    const { domElement } = (0, import_core46.getResources)(ctx);
+    detachKeyboardListeners(domElement);
+    detachMouseListeners(domElement);
+    detachScreenObserver(domElement);
+    detachPointerListeners(domElement);
+  }
+};
+
+// src/Editor.ts
+var import_canvas_store32 = require("@woven-ecs/canvas-store");
+var import_core47 = require("@woven-ecs/core");
+
+// src/FontLoader.ts
+var import_zod2 = require("zod");
+var FontFamily = import_zod2.z.object({
+  /** The CSS font-family name */
+  name: import_zod2.z.string(),
+  /** Display name shown in the font selector UI */
+  displayName: import_zod2.z.string(),
+  /** URL to the font stylesheet (e.g., Google Fonts URL) */
+  url: import_zod2.z.string(),
+  /** Optional preview image URL for the font selector */
+  previewImage: import_zod2.z.string().optional(),
+  /** Whether this font appears in the font selector (default: true) */
+  selectable: import_zod2.z.boolean().default(true),
+  /**
+   * Font weights to load (e.g., [400, 700] for regular and bold).
+   * Only applies to Google Fonts URLs - will auto-construct the variant URL.
+   * Default: [400, 700]
+   */
+  weights: import_zod2.z.array(import_zod2.z.number()).default([400, 700]),
+  /**
+   * Whether to also load italic variants for each weight.
+   * Only applies to Google Fonts URLs.
+   * Default: true
+   */
+  italics: import_zod2.z.boolean().default(true)
+});
+var FontLoader = class {
+  constructor() {
+    this.loadedFonts = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Load multiple font families.
+   * Fonts that have already been loaded will be skipped.
+   *
+   * @param families - Array of font families to load
+   */
+  async loadFonts(families) {
+    const unloadedFamilies = families.filter((family) => !this.loadedFonts.has(family.name));
+    if (unloadedFamilies.length === 0) {
+      return;
+    }
+    const fontPromises = unloadedFamilies.map((family) => this.loadSingleFont(family));
+    await Promise.all(fontPromises);
+  }
+  /**
+   * Build a Google Fonts URL with weight and italic variants.
+   * Format: https://fonts.googleapis.com/css2?family=FontName:ital,wght@0,400;0,700;1,400;1,700
+   *
+   * @param family - Font family configuration
+   * @returns The constructed URL with variants
+   */
+  buildGoogleFontsUrl(family) {
+    const baseUrl = family.url;
+    if (!baseUrl.includes("fonts.googleapis.com")) {
+      return baseUrl;
+    }
+    const urlObj = new URL(baseUrl);
+    const familyParam = urlObj.searchParams.get("family");
+    if (!familyParam) {
+      return baseUrl;
+    }
+    const baseFamilyName = familyParam.split(":")[0];
+    const weights = family.weights;
+    const variants = [];
+    if (family.italics) {
+      for (const weight of weights) {
+        variants.push(`0,${weight}`);
+      }
+      for (const weight of weights) {
+        variants.push(`1,${weight}`);
+      }
+      urlObj.searchParams.set("family", `${baseFamilyName}:ital,wght@${variants.join(";")}`);
+    } else {
+      urlObj.searchParams.set("family", `${baseFamilyName}:wght@${weights.join(";")}`);
+    }
+    return urlObj.toString();
+  }
+  /**
+   * Load a single font family.
+   * Adds a link element to the document head and waits for the font to be ready.
+   *
+   * @param family - Font family to load
+   */
+  loadSingleFont(family) {
+    this.loadedFonts.add(family.name);
+    return new Promise((resolve, reject) => {
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = this.buildGoogleFontsUrl(family);
+      link.onload = async () => {
+        try {
+          const loadPromises = this.getFontLoadPromises(family);
+          await Promise.all(loadPromises);
+          await document.fonts.ready;
+          resolve();
+        } catch (error) {
+          reject(new Error(`Failed to load font face for: ${family.name}. ${error}`));
+        }
+      };
+      link.onerror = () => {
+        reject(new Error(`Failed to load font stylesheet: ${family.name}`));
+      };
+      document.head.appendChild(link);
+    });
+  }
+  /**
+   * Get promises for loading all font variants (weights and italics).
+   *
+   * @param family - Font family configuration
+   * @returns Array of promises for loading each font variant
+   */
+  getFontLoadPromises(family) {
+    const promises = [];
+    const fontName = family.name;
+    for (const weight of family.weights) {
+      promises.push(document.fonts.load(`${weight} 12px "${fontName}"`));
+      if (family.italics) {
+        promises.push(document.fonts.load(`italic ${weight} 12px "${fontName}"`));
+      }
+    }
+    return promises;
+  }
+  /**
+   * Check if a font has been loaded.
+   *
+   * @param fontName - The font-family name to check
+   * @returns True if the font has been loaded
+   */
+  isLoaded(fontName) {
+    return this.loadedFonts.has(fontName);
+  }
+  /**
+   * Get the set of loaded font names.
+   */
+  getLoadedFonts() {
+    return this.loadedFonts;
+  }
+};
+
+// src/plugin.ts
+function parsePlugin(input) {
+  if (typeof input === "function") {
+    return input({});
+  }
+  return input;
+}
+function sortPluginsByDependencies(plugins) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const pluginMap = new Map(plugins.map((p) => [p.name, p]));
+  function visit(plugin) {
+    if (visited.has(plugin.name)) return;
+    if (visiting.has(plugin.name)) {
+      throw new Error(`Circular plugin dependency detected: ${plugin.name}`);
+    }
+    visiting.add(plugin.name);
+    for (const depName of plugin.dependencies ?? []) {
+      const dep = pluginMap.get(depName);
+      if (!dep) {
+        throw new Error(`Plugin "${plugin.name}" depends on "${depName}" which is not registered`);
+      }
+      visit(dep);
+    }
+    visiting.delete(plugin.name);
+    visited.add(plugin.name);
+    sorted.push(plugin);
+  }
+  for (const plugin of plugins) {
+    visit(plugin);
+  }
+  return sorted;
+}
+
+// src/Editor.ts
+var PHASE_ORDER = ["input", "capture", "update", "render"];
+function batchSystems(systems) {
+  const byPhase = /* @__PURE__ */ new Map();
+  for (const phase of PHASE_ORDER) {
+    byPhase.set(phase, []);
+  }
+  for (const system of systems) {
+    byPhase.get(system.phase).push(system);
+  }
+  const result = [];
+  for (const phase of PHASE_ORDER) {
+    const phaseSystems = byPhase.get(phase);
+    const byPriority = /* @__PURE__ */ new Map();
+    for (const system of phaseSystems) {
+      const group = byPriority.get(system.priority) ?? [];
+      group.push(system);
+      byPriority.set(system.priority, group);
+    }
+    const priorities = [...byPriority.keys()].sort((a, b) => b - a);
+    for (const p of priorities) {
+      result.push(byPriority.get(p));
+    }
+  }
+  return result;
+}
+var Editor = class {
+  constructor(domElement, optionsInput) {
+    this.cursors = {};
+    this.blockDefs = {};
+    this.fonts = [];
+    this.components = [];
+    this.singletons = [];
+    const options = EditorOptionsSchema.parse(optionsInput ?? {});
+    const { plugins: pluginInputs, maxEntities } = options;
+    const user = UserData.parse(options.user ?? {});
+    this.userData = user;
+    this.gridOptions = GridOptions.parse(options.grid ?? {});
+    this.controlsOptions = ControlsOptions.parse(options.controls ?? {});
+    const plugins = pluginInputs.map(parsePlugin);
+    const sortedPlugins = sortPluginsByDependencies([CorePlugin, ...plugins]);
+    const allDefs = [CommandMarker, import_canvas_store32.Synced];
+    for (const plugin of sortedPlugins) {
+      if (plugin.components) {
+        allDefs.push(...plugin.components);
+      }
+      if (plugin.singletons) {
+        allDefs.push(...plugin.singletons);
+      }
+    }
+    allDefs.push(...options.components);
+    allDefs.push(...options.singletons);
+    const keybinds = options.keybinds;
+    if (!options.omitPluginKeybinds) {
+      for (const plugin of sortedPlugins) {
+        if (plugin.keybinds) {
+          keybinds.push(...plugin.keybinds);
+        }
+      }
+    }
+    this.keybinds = keybinds;
+    const blockDefs = {};
+    for (const input of options.blockDefs) {
+      const parsed = BlockDef2.parse(input);
+      blockDefs[parsed.tag] = parsed;
+    }
+    for (const plugin of sortedPlugins) {
+      if (plugin.blockDefs) {
+        for (const input of plugin.blockDefs) {
+          const parsed = BlockDef2.parse(input);
+          blockDefs[parsed.tag] = parsed;
+        }
+      }
+    }
+    this.blockDefs = blockDefs;
+    const cursors = {};
+    Object.assign(cursors, options.cursors);
+    if (!options.omitPluginCursors) {
+      for (const plugin of sortedPlugins) {
+        if (plugin.cursors) {
+          Object.assign(cursors, plugin.cursors);
+        }
+      }
+    }
+    this.cursors = cursors;
+    this.fontLoader = new FontLoader();
+    const fontInputs = [...options.fonts];
+    if (!options.omitPluginFonts) {
+      for (const plugin of sortedPlugins) {
+        if (plugin.fonts) {
+          fontInputs.push(...plugin.fonts);
+        }
+      }
+    }
+    this.fonts = fontInputs.map((input) => FontFamily.parse(input));
+    const pluginResources = {};
+    for (const plugin of sortedPlugins) {
+      if (plugin.resources !== void 0) {
+        pluginResources[plugin.name] = plugin.resources;
+      }
+    }
+    const componentsByName = /* @__PURE__ */ new Map();
+    const singletonsByName = /* @__PURE__ */ new Map();
+    const componentsById = /* @__PURE__ */ new Map();
+    const singletonsById = /* @__PURE__ */ new Map();
+    const allResources = {
+      domElement,
+      editor: this,
+      userId: user.userId,
+      sessionId: user.sessionId,
+      pluginResources,
+      componentsByName,
+      singletonsByName,
+      componentsById,
+      singletonsById
+    };
+    this.world = new import_core47.World(allDefs, {
+      maxEntities,
+      resources: allResources
+    });
+    const allSystems = [];
+    for (const plugin of sortedPlugins) {
+      if (plugin.systems) {
+        allSystems.push(...plugin.systems);
+      }
+    }
+    allSystems.push(...options.systems);
+    this.systemBatches = batchSystems(allSystems);
+    this.plugins = new Map(sortedPlugins.map((p) => [p.name, p]));
+    for (const plugin of sortedPlugins) {
+      if (plugin.components) {
+        for (const comp of plugin.components) {
+          const componentId = comp._getComponentId(this.ctx);
+          componentsById.set(componentId, comp);
+          componentsByName.set(comp.name, comp);
+        }
+      }
+      if (plugin.singletons) {
+        for (const singleton of plugin.singletons) {
+          const componentId = singleton._getComponentId(this.ctx);
+          singletonsById.set(componentId, singleton);
+          singletonsByName.set(singleton.name, singleton);
+        }
+      }
+    }
+    for (const comp of options.components) {
+      const componentId = comp._getComponentId(this.ctx);
+      componentsById.set(componentId, comp);
+      componentsByName.set(comp.name, comp);
+    }
+    for (const singleton of options.singletons) {
+      const componentId = singleton._getComponentId(this.ctx);
+      singletonsById.set(componentId, singleton);
+      singletonsByName.set(singleton.name, singleton);
+    }
+    this.components = [...componentsByName.values()];
+    this.singletons = [...singletonsByName.values()];
+  }
+  /**
+   * Get the ECS context.
+   * Use this to access ECS functions and resources.
+   */
+  get ctx() {
+    return this.world._getContext();
+  }
+  /**
+   * Initialize the editor.
+   * Call this after construction to run async setup.
+   */
+  async initialize() {
+    if (this.fonts.length > 0) {
+      await this.fontLoader.loadFonts(this.fonts);
+    }
+    Grid.copy(this.ctx, this.gridOptions);
+    Controls.copy(this.ctx, this.controlsOptions);
+    this.nextTick((ctx) => {
+      const userEntity = (0, import_core47.createEntity)(ctx);
+      (0, import_core47.addComponent)(ctx, userEntity, import_canvas_store32.Synced, {
+        id: crypto.randomUUID()
+      });
+      (0, import_core47.addComponent)(ctx, userEntity, User, {
+        userId: this.userData.userId,
+        sessionId: this.userData.sessionId,
+        color: this.userData.color,
+        name: this.userData.name,
+        avatar: this.userData.avatar
+      });
+    });
+    for (const plugin of this.plugins.values()) {
+      if (plugin.setup) {
+        await plugin.setup(this.ctx);
+      }
+    }
+  }
+  /**
+   * Run one frame of the editor loop.
+   *
+   * Executes systems in phase order:
+   * 1. Input - convert raw events to ECS state
+   * 2. Capture - detect targets, compute intersections
+   * 3. Update - modify document state, process commands
+   * 4. Render - sync ECS state to output
+   *
+   * Commands spawned via `command()` are available during this frame
+   * and automatically cleaned up at the end.
+   */
+  async tick() {
+    this.world.sync();
+    for (const batch of this.systemBatches) {
+      const systems = batch.map((s) => s._system);
+      await this.world.execute(...systems);
+    }
+    const currentEventIndex = this.ctx.eventBuffer.getWriteIndex();
+    this.ctx.prevEventIndex = currentEventIndex;
+    this.ctx.currEventIndex = currentEventIndex;
+    cleanupCommands(this.ctx);
+  }
+  /**
+   * Schedule work for the next tick.
+   * Use this from event handlers to safely modify ECS state.
+   *
+   * @param callback - Function to execute at next tick
+   *
+   * @example
+   * ```typescript
+   * element.addEventListener('click', () => {
+   *   editor.nextTick((ctx) => {
+   *     const block = Block.write(ctx, entityId);
+   *     block.selected = true;
+   *   });
+   * });
+   * ```
+   */
+  nextTick(callback) {
+    return this.world.nextSync((ctx) => {
+      callback(ctx);
+    });
+  }
+  /**
+   * Spawn a command to be processed this frame.
+   * Commands are ephemeral entities that systems can react to via `CommandDef.iter()`.
+   *
+   * @param def - The command definition created with `defineCommand()`
+   * @param payload - Command payload data
+   *
+   * @example
+   * ```typescript
+   * const SelectAll = defineCommand<{ filter?: string }>("select-all");
+   *
+   * // From UI event handler
+   * editor.command(SelectAll, { filter: "blocks" });
+   * ```
+   */
+  command(def, ...args) {
+    const payload = args[0];
+    this.nextTick((ctx) => {
+      def.spawn(ctx, payload);
+    });
+  }
+  /**
+   * Subscribe to query changes.
+   *
+   * @param query - Query definition
+   * @param callback - Called when query results change
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = editor.subscribe(selectedBlocks, (ctx, { added, removed }) => {
+   *   console.log('Selection changed:', added, removed);
+   * });
+   *
+   * // Later:
+   * unsubscribe();
+   * ```
+   */
+  subscribe(query, callback) {
+    return this.world.subscribe(query, (ctx, result) => {
+      callback(ctx, result);
+    });
+  }
+  /**
+   * Get the ECS context.
+   * Only for testing and advanced use cases.
+   * @internal
+   */
+  _getContext() {
+    return this.ctx;
+  }
+  /**
+   * Clean up the editor.
+   * Call this when done to release resources.
+   */
+  dispose() {
+    const plugins = Array.from(this.plugins.values()).reverse();
+    for (const plugin of plugins) {
+      if (plugin.teardown) {
+        plugin.teardown(this.ctx);
+      }
+    }
+    this.world.dispose();
+    this.plugins.clear();
+    this.systemBatches = [];
+  }
+};
+
+// src/EditorStateDef.ts
+var import_canvas_store33 = require("@woven-ecs/canvas-store");
+
+// src/machine.ts
+var import_xstate = require("xstate");
+function runMachine(machine, currentState, context, events) {
+  if (events.length === 0) {
+    return { value: currentState, context };
+  }
+  let state = machine.resolveState({
+    value: String(currentState),
+    context
+  });
+  for (const event of events) {
+    const [nextState, actions] = (0, import_xstate.transition)(machine, state, event);
+    state = nextState;
+    for (const action of actions) {
+      if (typeof action.exec === "function") {
+        action.exec(action.info, action.params);
+      }
+    }
+  }
+  return {
+    value: state.value,
+    context: state.context
+  };
+}
+
+// src/EditorStateDef.ts
+var EditorStateDef = class extends import_canvas_store33.CanvasSingletonDef {
+  constructor(name, schema) {
+    super({ name, sync: "none" }, schema);
+  }
+  /**
+   * Get the current state value.
+   *
+   * @param ctx - The ECS context
+   * @returns The current state machine state value
+   */
+  getState(ctx) {
+    return this.read(ctx).state;
+  }
+  /**
+   * Get the machine context (all fields except 'state').
+   *
+   * @param ctx - The ECS context
+   * @returns Plain object with context field values
+   */
+  getContext(ctx) {
+    const snapshot = this.snapshot(ctx);
+    const result = {};
+    for (const key of Object.keys(snapshot)) {
+      if (key !== "state") {
+        result[key] = snapshot[key];
+      }
+    }
+    return result;
+  }
+  /**
+   * Run an XState machine through events and update the singleton state.
+   *
+   * This method encapsulates the common pattern of:
+   * 1. Reading the current state and context
+   * 2. Running the machine through events
+   * 3. Writing the updated state and context back
+   *
+   * @param ctx - The ECS context
+   * @param machine - The XState machine definition
+   * @param events - Array of events to process (must have a 'type' property)
+   * @returns The resulting state value and context
+   *
+   * @example
+   * ```typescript
+   * const capturePanSystem = defineSystem((ctx) => {
+   *   const events = getPointerInput(ctx, ["middle"]);
+   *   if (events.length === 0) return;
+   *
+   *   PanState.run(ctx, createPanMachine(ctx), events);
+   * });
+   * ```
+   */
+  run(ctx, machine, events) {
+    const currentState = this.getState(ctx);
+    const currentContext = this.getContext(ctx);
+    const result = runMachine(
+      machine,
+      currentState,
+      currentContext,
+      events
+    );
+    const writable = this.write(ctx);
+    writable.state = result.value;
+    for (const [key, value] of Object.entries(result.context)) {
+      ;
+      writable[key] = value;
+    }
+    return result;
+  }
+};
+function defineEditorState(name, schema) {
+  return new EditorStateDef(name, schema);
+}
+
+// src/events/frameInputEvents.ts
+function getFrameInput(ctx) {
+  const frame = Frame.read(ctx);
+  return {
+    type: "frame",
+    ctx,
+    delta: frame.delta,
+    frameNumber: frame.number,
+    time: frame.time
+  };
+}
+
+// src/events/keyboardInputEvents.ts
+function getKeyboardInput(ctx, keys) {
+  const events = [];
+  for (const key of keys) {
+    if (Keyboard.isKeyDownTrigger(ctx, key)) {
+      events.push({ type: "keyDown", key, ctx });
+    }
+    if (Keyboard.isKeyUpTrigger(ctx, key)) {
+      events.push({ type: "keyUp", key, ctx });
+    }
+  }
+  return events;
+}
+
+// src/events/mouseInputEvents.ts
+function getMouseInput(ctx) {
+  const events = [];
+  const mouse = Mouse.read(ctx);
+  const screenPos = [mouse.position[0], mouse.position[1]];
+  const worldPos = Camera.toWorld(ctx, screenPos);
+  if (mouse.wheelTrigger) {
+    events.push({
+      type: "wheel",
+      ctx,
+      screenPosition: screenPos,
+      worldPosition: worldPos,
+      wheelDeltaX: mouse.wheelDeltaX,
+      wheelDeltaY: mouse.wheelDeltaY
+    });
+  }
+  if (mouse.moveTrigger) {
+    events.push({
+      type: "mouseMove",
+      ctx,
+      screenPosition: screenPos,
+      worldPosition: worldPos,
+      wheelDeltaX: 0,
+      wheelDeltaY: 0
+    });
+  }
+  return events;
+}
+
+// src/events/pointerInputEvents.ts
+var import_math9 = require("@woven-canvas/math");
+var import_core48 = require("@woven-ecs/core");
+var DEFAULT_CLICK_MOVE_THRESHOLD = 3;
+var DEFAULT_CLICK_FRAME_THRESHOLD = 30;
+var pointerQuery3 = (0, import_core48.defineQuery)((q) => q.tracking(Pointer));
+var trackingState = /* @__PURE__ */ new Map();
+function getTrackingState(ctx) {
+  const key = ctx.readerId;
+  let state = trackingState.get(key);
+  if (!state) {
+    state = {
+      prevPositions: /* @__PURE__ */ new Map(),
+      prevModifiers: {
+        shiftDown: false,
+        altDown: false,
+        modDown: false
+      },
+      prevCamera: {
+        left: 0,
+        top: 0,
+        zoom: 1
+      }
+    };
+    trackingState.set(key, state);
+  }
+  return state;
+}
+function getPointerInput(ctx, buttons, options = {}) {
+  if (buttons.length === 0) return [];
+  const {
+    includeFrameEvent = false,
+    clickMoveThreshold = DEFAULT_CLICK_MOVE_THRESHOLD,
+    clickFrameThreshold = DEFAULT_CLICK_FRAME_THRESHOLD
+  } = options;
+  const state = getTrackingState(ctx);
+  const frameNumber = Frame.read(ctx).number;
+  const events = [];
+  const keyboard = Keyboard.read(ctx);
+  const modifiers = {
+    shiftDown: keyboard.shiftDown,
+    altDown: keyboard.altDown,
+    modDown: keyboard.modDown
+  };
+  const camera = Camera.read(ctx);
+  const matchesButtons = (entityId) => {
+    const pointer = Pointer.read(ctx, entityId);
+    return buttons.includes(pointer.button);
+  };
+  const intersects = Intersect.getAll(ctx);
+  const createEvent = (type, entityId) => {
+    const pointer = Pointer.read(ctx, entityId);
+    const screenPos = [pointer.position[0], pointer.position[1]];
+    const worldPos = Camera.toWorld(ctx, screenPos);
+    return {
+      type,
+      ctx,
+      screenPosition: screenPos,
+      worldPosition: worldPos,
+      velocity: [pointer._velocity[0], pointer._velocity[1]],
+      pressure: pointer.pressure,
+      button: pointer.button,
+      pointerType: pointer.pointerType,
+      obscured: pointer.obscured,
+      shiftDown: modifiers.shiftDown,
+      altDown: modifiers.altDown,
+      modDown: modifiers.modDown,
+      cameraLeft: camera.left,
+      cameraTop: camera.top,
+      cameraZoom: camera.zoom,
+      pointerId: entityId,
+      intersects
+    };
+  };
+  const addedPointers = pointerQuery3.added(ctx);
+  const removedPointers = pointerQuery3.removed(ctx);
+  const changedPointers = pointerQuery3.changed(ctx);
+  const currentPointers = pointerQuery3.current(ctx);
+  const matchingAdded = addedPointers.filter(matchesButtons);
+  const matchingRemoved = removedPointers.filter(matchesButtons);
+  const matchingChanged = changedPointers.filter(matchesButtons);
+  const matchingCurrent = Array.from(currentPointers).filter(matchesButtons);
+  const escapePressed = Keyboard.isKeyDownTrigger(ctx, Key.Escape);
+  const multiTouch = matchingCurrent.length > 1 && matchingAdded.length > 0;
+  if ((escapePressed || multiTouch) && matchingCurrent.length > 0) {
+    events.push(createEvent("cancel", matchingCurrent[0]));
+    return events;
+  }
+  if (matchingAdded.length > 0 && matchingCurrent.length === 1) {
+    const entityId = matchingCurrent[0];
+    const pointer = Pointer.read(ctx, entityId);
+    if (!pointer.obscured) {
+      events.push(createEvent("pointerDown", entityId));
+      state.prevPositions.set(entityId, [pointer.position[0], pointer.position[1]]);
+    }
+  }
+  if (matchingRemoved.length > 0 && matchingCurrent.length === 0) {
+    const entityId = matchingRemoved[0];
+    const pointer = Pointer.read(ctx, entityId);
+    events.push(createEvent("pointerUp", entityId));
+    const downPos = state.prevPositions.get(entityId);
+    if (downPos) {
+      const currentPos = [pointer.position[0], pointer.position[1]];
+      const dist = import_math9.Vec2.distance(downPos, currentPos);
+      const deltaFrame = frameNumber - pointer.downFrame;
+      if (dist < clickMoveThreshold && deltaFrame < clickFrameThreshold) {
+        events.push(createEvent("click", entityId));
+      }
+      state.prevPositions.delete(entityId);
+    }
+  }
+  const modifiersChanged = modifiers.shiftDown !== state.prevModifiers.shiftDown || modifiers.altDown !== state.prevModifiers.altDown || modifiers.modDown !== state.prevModifiers.modDown;
+  const cameraChanged = camera.left !== state.prevCamera.left || camera.top !== state.prevCamera.top || camera.zoom !== state.prevCamera.zoom;
+  if ((matchingChanged.length > 0 || modifiersChanged || cameraChanged) && matchingCurrent.length === 1) {
+    events.push(createEvent("pointerMove", matchingCurrent[0]));
+  }
+  if (includeFrameEvent && matchingCurrent.length === 1) {
+    events.push(createEvent("frame", matchingCurrent[0]));
+  }
+  state.prevModifiers = { ...modifiers };
+  state.prevCamera = { left: camera.left, top: camera.top, zoom: camera.zoom };
+  return events;
+}
+function clearPointerTrackingState(ctx) {
+  trackingState.delete(ctx.readerId);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Aabb,
+  Asset,
+  Block,
+  BlockDef,
+  Camera,
+  CanvasComponentDef,
+  CanvasSingletonDef,
+  Color,
+  CommandMarker,
+  ComponentDef,
+  Connector,
+  Controls,
+  ControlsOptions,
+  CorePlugin,
+  Cursor,
+  CursorDef,
+  Edited,
+  Editor,
+  EditorStateDef,
+  EventType,
+  FontFamily,
+  FontLoader,
+  Frame,
+  Grid,
+  GridOptions,
+  Held,
+  HitGeometry,
+  Hovered,
+  Image,
+  Intersect,
+  Key,
+  Keybind,
+  Keyboard,
+  MAX_HIT_ARCS,
+  MAX_HIT_CAPSULES,
+  MainThreadSystem,
+  Mouse,
+  Opacity,
+  Pointer,
+  PointerButton,
+  PointerType,
+  RankBounds,
+  Redo,
+  SINGLETON_ENTITY_ID,
+  STRATUM_ORDER,
+  ScaleWithZoom,
+  ScaleWithZoomState,
+  Screen,
+  Shape,
+  Stratum,
+  StrokeKind,
+  Synced,
+  Text,
+  TextAlignment,
+  Undo,
+  UploadState,
+  User,
+  UserData,
+  VerticalAlign,
+  VerticalAlignment,
+  addComponent,
+  canBlockEdit,
+  clearPointerTrackingState,
+  createEntity,
+  defineCanvasComponent,
+  defineCanvasSingleton,
+  defineCommand,
+  defineEditorState,
+  defineEditorSystem,
+  defineQuery,
+  defineSystem,
+  field,
+  getBackrefs,
+  getBlockDef,
+  getFrameInput,
+  getKeyboardInput,
+  getMouseInput,
+  getPluginResources,
+  getPointerInput,
+  getResources,
+  getTopmostBlockAtPoint,
+  hasComponent,
+  intersectAabb,
+  intersectCapsule,
+  intersectPoint,
+  isAlive,
+  isHeldByRemote,
+  on,
+  parsePlugin,
+  removeComponent,
+  removeEntity,
+  runMachine
+});
+//# sourceMappingURL=index.cjs.map