@woven-canvas/core 1.0.0 → 1.0.2

package/build/index.js

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 import {
   CanvasComponentDef as CanvasComponentDef7,
   CanvasSingletonDef as CanvasSingletonDef12,
-  defineCanvasComponent as defineCanvasComponent13,
+  defineCanvasComponent as defineCanvasComponent14,
   defineCanvasSingleton as defineCanvasSingleton3,
   Synced as Synced4
 } from "@woven-ecs/canvas-store";
@@ -19,7 +19,7 @@ import {
   defineQuery as defineQuery11,
   defineSystem,
   EventType,
-  field as field28,
+  field as field29,
   getBackrefs,
   getResources as getResources13,
   hasComponent as hasComponent7,
@@ -46,6 +46,8 @@ __export(components_exports, {
   Color: () => Color,
   Connector: () => Connector,
   Edited: () => Edited,
+  Embed: () => Embed,
+  EmbedProvider: () => EmbedProvider,
   Held: () => Held,
   HitGeometry: () => HitGeometry,
   Hovered: () => Hovered,
@@ -164,7 +166,7 @@ var ControlsOptions = z.object({
    * Tool activated by right mouse button.
    * @default 'menu'
    */
-  rightMouseTool: z.string().max(32).default("menu"),
+  rightMouseTool: z.string().max(32).default("hand"),
   /**
    * Tool activated by mouse wheel.
    * @default 'scroll'
@@ -325,7 +327,7 @@ var BlockDef = z.object({
   resizeMode: z.enum([ResizeMode.Scale, ResizeMode.Text, ResizeMode.Free, ResizeMode.GroupOnly]).default(ResizeMode.Scale),
   canRotate: z.boolean().default(true),
   canScale: z.boolean().default(true),
-  selectable: z.boolean().default(true),
+  interactable: z.boolean().default(true),
   connectors: BlockDefConnectors.default(BlockDefConnectors.parse({}))
 });
 
@@ -722,30 +724,57 @@ var Connector = defineCanvasComponent2(
 import { defineCanvasComponent as defineCanvasComponent3 } from "@woven-ecs/canvas-store";
 var Edited = defineCanvasComponent3({ name: "edited" }, {});
 
-// src/components/Held.ts
+// src/components/Embed.ts
 import { defineCanvasComponent as defineCanvasComponent4 } from "@woven-ecs/canvas-store";
 import { field as field6 } from "@woven-ecs/core";
-var Held = defineCanvasComponent4(
+var EmbedProvider = /* @__PURE__ */ ((EmbedProvider2) => {
+  EmbedProvider2["GoogleMaps"] = "google-maps";
+  EmbedProvider2["GoogleCalendar"] = "google-calendar";
+  EmbedProvider2["GoogleSlides"] = "google-slides";
+  EmbedProvider2["Tldraw"] = "tldraw";
+  EmbedProvider2["Figma"] = "figma";
+  EmbedProvider2["GithubGist"] = "github-gist";
+  EmbedProvider2["Youtube"] = "youtube";
+  EmbedProvider2["Spotify"] = "spotify";
+  EmbedProvider2["Unknown"] = "unknown";
+  return EmbedProvider2;
+})(EmbedProvider || {});
+var Embed = defineCanvasComponent4(
+  { name: "embed", sync: "document" },
+  {
+    /** The original URL provided by the user */
+    url: field6.string().max(2048).default(""),
+    /** The resolved embed/iframe URL */
+    embedUrl: field6.string().max(2048).default(""),
+    /** The embed provider (used for provider-specific styling/behavior) */
+    provider: field6.enum(EmbedProvider).default("unknown" /* Unknown */)
+  }
+);
+
+// src/components/Held.ts
+import { defineCanvasComponent as defineCanvasComponent5 } from "@woven-ecs/canvas-store";
+import { field as field7 } from "@woven-ecs/core";
+var Held = defineCanvasComponent5(
   { name: "held", sync: "ephemeral" },
   {
-    sessionId: field6.string().max(36).default("")
+    sessionId: field7.string().max(36).default("")
   }
 );
 
 // src/components/HitGeometry.ts
 import { Arc, Capsule, Mat2 } from "@woven-canvas/math";
 import { CanvasComponentDef as CanvasComponentDef4 } from "@woven-ecs/canvas-store";
-import { field as field7 } from "@woven-ecs/core";
+import { field as field8 } from "@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: field7.buffer(field7.float32()).size(MAX_HIT_CAPSULES * FLOATS_PER_CAPSULE),
-  capsuleCount: field7.uint16().default(0),
-  hitArcs: field7.buffer(field7.float32()).size(MAX_HIT_ARCS * FLOATS_PER_ARC),
-  arcCount: field7.uint16().default(0)
+  hitCapsules: field8.buffer(field8.float32()).size(MAX_HIT_CAPSULES * FLOATS_PER_CAPSULE),
+  capsuleCount: field8.uint16().default(0),
+  hitArcs: field8.buffer(field8.float32()).size(MAX_HIT_ARCS * FLOATS_PER_ARC),
+  arcCount: field8.uint16().default(0)
 };
 var HitGeometryDef = class extends CanvasComponentDef4 {
   constructor() {
@@ -1051,37 +1080,37 @@ var HitGeometryDef = class extends CanvasComponentDef4 {
 var HitGeometry = new HitGeometryDef();
 
 // src/components/Hovered.ts
-import { defineCanvasComponent as defineCanvasComponent5 } from "@woven-ecs/canvas-store";
-var Hovered = defineCanvasComponent5({ name: "hovered" }, {});
+import { defineCanvasComponent as defineCanvasComponent6 } from "@woven-ecs/canvas-store";
+var Hovered = defineCanvasComponent6({ name: "hovered" }, {});
 
 // src/components/Image.ts
-import { defineCanvasComponent as defineCanvasComponent6 } from "@woven-ecs/canvas-store";
-import { field as field8 } from "@woven-ecs/core";
-var Image = defineCanvasComponent6(
+import { defineCanvasComponent as defineCanvasComponent7 } from "@woven-ecs/canvas-store";
+import { field as field9 } from "@woven-ecs/core";
+var Image = defineCanvasComponent7(
   { name: "image", sync: "document" },
   {
     /** Image width in pixels */
-    width: field8.uint16().default(0),
+    width: field9.uint16().default(0),
     /** Image height in pixels */
-    height: field8.uint16().default(0),
+    height: field9.uint16().default(0),
     /** Alt text for accessibility */
-    alt: field8.string().max(256).default("")
+    alt: field9.string().max(256).default("")
   }
 );
 
 // src/components/Opacity.ts
-import { defineCanvasComponent as defineCanvasComponent7 } from "@woven-ecs/canvas-store";
-import { field as field9 } from "@woven-ecs/core";
-var Opacity = defineCanvasComponent7(
+import { defineCanvasComponent as defineCanvasComponent8 } from "@woven-ecs/canvas-store";
+import { field as field10 } from "@woven-ecs/core";
+var Opacity = defineCanvasComponent8(
   { name: "opacity" },
   {
-    value: field9.uint8().default(255)
+    value: field10.uint8().default(255)
   }
 );
 
 // src/components/Pointer.ts
 import { CanvasComponentDef as CanvasComponentDef5 } from "@woven-ecs/canvas-store";
-import { field as field10 } from "@woven-ecs/core";
+import { field as field11 } from "@woven-ecs/core";
 var PointerButton = {
   None: "none",
   Left: "left",
@@ -1098,30 +1127,30 @@ var PointerType = {
 var SAMPLE_COUNT = 6;
 var PointerSchema = {
   /** Unique pointer ID (from PointerEvent.pointerId) */
-  pointerId: field10.uint16().default(0),
+  pointerId: field11.uint16().default(0),
   /** Current position relative to the editor element [x, y] */
-  position: field10.tuple(field10.float32(), 2).default([0, 0]),
+  position: field11.tuple(field11.float32(), 2).default([0, 0]),
   /** Position where the pointer went down [x, y] */
-  downPosition: field10.tuple(field10.float32(), 2).default([0, 0]),
+  downPosition: field11.tuple(field11.float32(), 2).default([0, 0]),
   /** Frame number when the pointer went down (for click detection) */
-  downFrame: field10.uint32().default(0),
+  downFrame: field11.uint32().default(0),
   /** Which button is pressed */
-  button: field10.enum(PointerButton).default(PointerButton.None),
+  button: field11.enum(PointerButton).default(PointerButton.None),
   /** Type of pointer device */
-  pointerType: field10.enum(PointerType).default(PointerType.Mouse),
+  pointerType: field11.enum(PointerType).default(PointerType.Mouse),
   /** Pressure from 0 to 1 (for pen/touch) */
-  pressure: field10.float32().default(0),
+  pressure: field11.float32().default(0),
   /** Whether the pointer event target was not the editor element */
-  obscured: field10.boolean().default(false),
+  obscured: field11.boolean().default(false),
   // Velocity tracking (ring buffer for position samples)
   /** Ring buffer of previous positions [x0, y0, x1, y1, ...] @internal */
-  _prevPositions: field10.array(field10.float32(), SAMPLE_COUNT * 2),
+  _prevPositions: field11.array(field11.float32(), SAMPLE_COUNT * 2),
   /** Ring buffer of timestamps for each position sample @internal */
-  _prevTimes: field10.array(field10.float32(), SAMPLE_COUNT),
+  _prevTimes: field11.array(field11.float32(), SAMPLE_COUNT),
   /** Total number of samples added (used for ring buffer indexing) @internal */
-  _sampleCount: field10.int32().default(0),
+  _sampleCount: field11.int32().default(0),
   /** Computed velocity [vx, vy] in pixels per second @internal */
-  _velocity: field10.tuple(field10.float32(), 2).default([0, 0])
+  _velocity: field11.tuple(field11.float32(), 2).default([0, 0])
 };
 var PointerDef = class extends CanvasComponentDef5 {
   constructor() {
@@ -1232,103 +1261,103 @@ function addPointerSample(pointer, position, time) {
 }
 
 // src/components/ScaleWithZoom.ts
-import { defineCanvasComponent as defineCanvasComponent8 } from "@woven-ecs/canvas-store";
-import { field as field11 } from "@woven-ecs/core";
-var ScaleWithZoom = defineCanvasComponent8(
+import { defineCanvasComponent as defineCanvasComponent9 } from "@woven-ecs/canvas-store";
+import { field as field12 } from "@woven-ecs/core";
+var ScaleWithZoom = defineCanvasComponent9(
   { name: "scaleWithZoom" },
   {
     /** Pivot point for scaling as [x, y] (0-1, default 0.5,0.5 = center) */
-    anchor: field11.tuple(field11.float64(), 2).default([0.5, 0.5]),
+    anchor: field12.tuple(field12.float64(), 2).default([0.5, 0.5]),
     /** Initial position as [left, top] at zoom=1 */
-    startPosition: field11.tuple(field11.float64(), 2).default([0, 0]),
+    startPosition: field12.tuple(field12.float64(), 2).default([0, 0]),
     /** Initial size as [width, height] at zoom=1 */
-    startSize: field11.tuple(field11.float64(), 2).default([0, 0]),
+    startSize: field12.tuple(field12.float64(), 2).default([0, 0]),
     /** Scale multiplier per dimension: [x, y] (0 = no zoom effect, 1 = full zoom effect, 0.5 = half effect) */
-    scaleMultiplier: field11.tuple(field11.float64(), 2).default([1, 1])
+    scaleMultiplier: field12.tuple(field12.float64(), 2).default([1, 1])
   }
 );
 
 // src/components/Shape.ts
-import { defineCanvasComponent as defineCanvasComponent9 } from "@woven-ecs/canvas-store";
-import { field as field12 } from "@woven-ecs/core";
+import { defineCanvasComponent as defineCanvasComponent10 } from "@woven-ecs/canvas-store";
+import { field as field13 } from "@woven-ecs/core";
 var StrokeKind = {
   Solid: "solid",
   Dashed: "dashed",
   None: "none"
 };
-var Shape = defineCanvasComponent9(
+var Shape = defineCanvasComponent10(
   { name: "shape", sync: "document" },
   {
     /** The kind of shape to render (e.g. 'rectangle', 'ellipse', or custom shape key) */
-    kind: field12.string().default("rectangle"),
+    kind: field13.string().default("rectangle"),
     /** Stroke style */
-    strokeKind: field12.enum(StrokeKind).default(StrokeKind.Solid),
+    strokeKind: field13.enum(StrokeKind).default(StrokeKind.Solid),
     /** Stroke width in pixels */
-    strokeWidth: field12.uint16().default(2),
+    strokeWidth: field13.uint16().default(2),
     /** Stroke color - red component (0-255) */
-    strokeRed: field12.uint8().default(0),
+    strokeRed: field13.uint8().default(0),
     /** Stroke color - green component (0-255) */
-    strokeGreen: field12.uint8().default(0),
+    strokeGreen: field13.uint8().default(0),
     /** Stroke color - blue component (0-255) */
-    strokeBlue: field12.uint8().default(0),
+    strokeBlue: field13.uint8().default(0),
     /** Stroke color - alpha component (0-255) */
-    strokeAlpha: field12.uint8().default(255),
+    strokeAlpha: field13.uint8().default(255),
     /** Fill color - red component (0-255) */
-    fillRed: field12.uint8().default(255),
+    fillRed: field13.uint8().default(255),
     /** Fill color - green component (0-255) */
-    fillGreen: field12.uint8().default(255),
+    fillGreen: field13.uint8().default(255),
     /** Fill color - blue component (0-255) */
-    fillBlue: field12.uint8().default(255),
+    fillBlue: field13.uint8().default(255),
     /** Fill color - alpha component (0-255) */
-    fillAlpha: field12.uint8().default(0)
+    fillAlpha: field13.uint8().default(0)
   }
 );
 
 // src/components/Text.ts
-import { defineCanvasComponent as defineCanvasComponent10 } from "@woven-ecs/canvas-store";
-import { field as field13 } from "@woven-ecs/core";
-var Text = defineCanvasComponent10(
+import { defineCanvasComponent as defineCanvasComponent11 } from "@woven-ecs/canvas-store";
+import { field as field14 } from "@woven-ecs/core";
+var Text = defineCanvasComponent11(
   { name: "text", sync: "document" },
   {
     /** HTML content (supports rich text formatting) */
-    content: field13.string().max(1e4).default(""),
+    content: field14.string().max(1e4).default(""),
     /** Font size in pixels */
-    fontSizePx: field13.float64().default(24),
+    fontSizePx: field14.float64().default(24),
     /** Font family name */
-    fontFamily: field13.string().max(64).default("Figtree"),
+    fontFamily: field14.string().max(64).default("Figtree"),
     /** Line height multiplier */
-    lineHeight: field13.float64().default(1.2),
+    lineHeight: field14.float64().default(1.2),
     /** Letter spacing in em units */
-    letterSpacingEm: field13.float64().default(0),
+    letterSpacingEm: field14.float64().default(0),
     /** Whether width is constrained (text wraps) */
-    constrainWidth: field13.boolean().default(true),
+    constrainWidth: field14.boolean().default(true),
     /** Default text alignment for new paragraphs */
-    defaultAlignment: field13.enum(TextAlignment).default(TextAlignment.Left)
+    defaultAlignment: field14.enum(TextAlignment).default(TextAlignment.Left)
   }
 );
 
 // src/components/User.ts
-import { defineCanvasComponent as defineCanvasComponent11 } from "@woven-ecs/canvas-store";
-import { field as field14 } from "@woven-ecs/core";
-var User = defineCanvasComponent11(
+import { defineCanvasComponent as defineCanvasComponent12 } from "@woven-ecs/canvas-store";
+import { field as field15 } from "@woven-ecs/core";
+var User = defineCanvasComponent12(
   { name: "user", sync: "ephemeral" },
   {
-    userId: field14.string().max(36),
-    sessionId: field14.string().max(36),
-    color: field14.string().max(7),
-    name: field14.string().max(100),
-    avatar: field14.string().max(500),
-    position: field14.tuple(field14.float32(), 2).default([0, 0])
+    userId: field15.string().max(36),
+    sessionId: field15.string().max(36),
+    color: field15.string().max(7),
+    name: field15.string().max(100),
+    avatar: field15.string().max(500),
+    position: field15.tuple(field15.float32(), 2).default([0, 0])
   }
 );
 
 // src/components/VerticalAlign.ts
-import { defineCanvasComponent as defineCanvasComponent12 } from "@woven-ecs/canvas-store";
-import { field as field15 } from "@woven-ecs/core";
-var VerticalAlign = defineCanvasComponent12(
+import { defineCanvasComponent as defineCanvasComponent13 } from "@woven-ecs/canvas-store";
+import { field as field16 } from "@woven-ecs/core";
+var VerticalAlign = defineCanvasComponent13(
   { name: "verticalAlign", sync: "document" },
   {
-    value: field15.enum(VerticalAlignment).default(VerticalAlignment.Top)
+    value: field16.enum(VerticalAlignment).default(VerticalAlignment.Top)
   }
 );
 
@@ -1362,20 +1391,20 @@ __export(singletons_exports, {
 
 // src/singletons/Camera.ts
 import { CanvasSingletonDef as CanvasSingletonDef2 } from "@woven-ecs/canvas-store";
-import { field as field17 } from "@woven-ecs/core";
+import { field as field18 } from "@woven-ecs/core";
 
 // src/singletons/Screen.ts
 import { CanvasSingletonDef } from "@woven-ecs/canvas-store";
-import { field as field16 } from "@woven-ecs/core";
+import { field as field17 } from "@woven-ecs/core";
 var ScreenSchema = {
   /** Width of the editor element in pixels */
-  width: field16.float64().default(0),
+  width: field17.float64().default(0),
   /** Height of the editor element in pixels */
-  height: field16.float64().default(0),
+  height: field17.float64().default(0),
   /** Left offset of the editor element relative to the viewport */
-  left: field16.float64().default(0),
+  left: field17.float64().default(0),
   /** Top offset of the editor element relative to the viewport */
-  top: field16.float64().default(0)
+  top: field17.float64().default(0)
 };
 var ScreenDef = class extends CanvasSingletonDef {
   constructor() {
@@ -1402,15 +1431,15 @@ var Screen = new ScreenDef();
 // src/singletons/Camera.ts
 var CameraSchema = {
   /** Top position of the camera in world coordinates */
-  top: field17.float64().default(0),
+  top: field18.float64().default(0),
   /** Left position of the camera in world coordinates */
-  left: field17.float64().default(0),
+  left: field18.float64().default(0),
   /** Zoom level (1 = 100%, 2 = 200%, 0.5 = 50%) */
-  zoom: field17.float64().default(1),
+  zoom: field18.float64().default(1),
   /** Whether the camera viewport intersects any blocks */
-  canSeeBlocks: field17.boolean().default(true),
+  canSeeBlocks: field18.boolean().default(true),
   /** Reference to a block that the camera can currently see (for optimization) */
-  lastSeenBlock: field17.ref()
+  lastSeenBlock: field18.ref()
 };
 var CameraDef = class extends CanvasSingletonDef2 {
   constructor() {
@@ -1486,20 +1515,20 @@ var Camera = new CameraDef();
 
 // src/singletons/Controls.ts
 import { CanvasSingletonDef as CanvasSingletonDef3 } from "@woven-ecs/canvas-store";
-import { field as field18 } from "@woven-ecs/core";
+import { field as field19 } from "@woven-ecs/core";
 var ControlsSchema = {
   /** Tool activated by left mouse button */
-  leftMouseTool: field18.string().max(32).default("select"),
+  leftMouseTool: field19.string().max(32).default("select"),
   /** Tool activated by middle mouse button */
-  middleMouseTool: field18.string().max(32).default("hand"),
+  middleMouseTool: field19.string().max(32).default("hand"),
   /** Tool activated by right mouse button */
-  rightMouseTool: field18.string().max(32).default("menu"),
+  rightMouseTool: field19.string().max(32).default("hand"),
   /** Tool activated by mouse wheel */
-  wheelTool: field18.string().max(32).default("scroll"),
+  wheelTool: field19.string().max(32).default("scroll"),
   /** Tool activated by mouse wheel with modifier key held */
-  modWheelTool: field18.string().max(32).default("zoom"),
+  modWheelTool: field19.string().max(32).default("zoom"),
   /** JSON snapshot of block to place on next click (empty string = no placement active) */
-  heldSnapshot: field18.string().max(65536).default("")
+  heldSnapshot: field19.string().max(65536).default("")
 };
 var ControlsDef = class extends CanvasSingletonDef3 {
   constructor() {
@@ -1541,16 +1570,16 @@ var Controls = new ControlsDef();
 
 // src/singletons/Cursor.ts
 import { CanvasSingletonDef as CanvasSingletonDef4 } from "@woven-ecs/canvas-store";
-import { field as field19 } from "@woven-ecs/core";
+import { field as field20 } from "@woven-ecs/core";
 var CursorSchema = {
   /** Base cursor kind (from current tool) */
-  cursorKind: field19.string().max(64).default("select"),
+  cursorKind: field20.string().max(64).default("select"),
   /** Base cursor rotation in radians */
-  rotation: field19.float64().default(0),
+  rotation: field20.float64().default(0),
   /** Context-specific cursor kind (overrides cursorKind when set, e.g., during drag/hover) */
-  contextCursorKind: field19.string().max(64).default(""),
+  contextCursorKind: field20.string().max(64).default(""),
   /** Context cursor rotation in radians */
-  contextRotation: field19.float64().default(0)
+  contextRotation: field20.float64().default(0)
 };
 var CursorDef2 = class extends CanvasSingletonDef4 {
   constructor() {
@@ -1598,37 +1627,37 @@ var Cursor = new CursorDef2();
 
 // src/singletons/Frame.ts
 import { defineCanvasSingleton } from "@woven-ecs/canvas-store";
-import { field as field20 } from "@woven-ecs/core";
+import { field as field21 } from "@woven-ecs/core";
 var Frame = defineCanvasSingleton(
   { name: "frame" },
   {
     /** Current frame number (increments each tick) */
-    number: field20.uint32().default(0),
+    number: field21.uint32().default(0),
     /** Time since last frame in seconds */
-    delta: field20.float64().default(0),
+    delta: field21.float64().default(0),
     /** Timestamp of current frame in milliseconds (from performance.now()) */
-    time: field20.float64().default(0),
+    time: field21.float64().default(0),
     /** Timestamp of previous frame in milliseconds (0 if first frame) */
-    lastTime: field20.float64().default(0)
+    lastTime: field21.float64().default(0)
   }
 );
 
 // src/singletons/Grid.ts
 import { CanvasSingletonDef as CanvasSingletonDef5 } from "@woven-ecs/canvas-store";
-import { field as field21 } from "@woven-ecs/core";
+import { field as field22 } from "@woven-ecs/core";
 var GridSchema = {
   /** Whether grid snapping is enabled */
-  enabled: field21.boolean().default(false),
+  enabled: field22.boolean().default(false),
   /** Whether resized/rotated objects must stay aligned to the grid */
-  strict: field21.boolean().default(false),
+  strict: field22.boolean().default(false),
   /** Width of each grid column in world units */
-  colWidth: field21.float64().default(20),
+  colWidth: field22.float64().default(20),
   /** Height of each grid row in world units */
-  rowHeight: field21.float64().default(20),
+  rowHeight: field22.float64().default(20),
   /** Angular snap increment in radians when grid is enabled */
-  snapAngleRad: field21.float64().default(Math.PI / 36),
+  snapAngleRad: field22.float64().default(Math.PI / 36),
   /** Angular snap increment in radians when shift key is held */
-  shiftSnapAngleRad: field21.float64().default(Math.PI / 12)
+  shiftSnapAngleRad: field22.float64().default(Math.PI / 12)
 };
 var GridDef = class extends CanvasSingletonDef5 {
   constructor() {
@@ -1691,14 +1720,14 @@ var Grid = new GridDef();
 
 // src/singletons/Intersect.ts
 import { CanvasSingletonDef as CanvasSingletonDef6 } from "@woven-ecs/canvas-store";
-import { field as field22 } from "@woven-ecs/core";
+import { field as field23 } from "@woven-ecs/core";
 var IntersectSchema = {
   // Store up to 5 intersected entity IDs
-  entity1: field22.ref(),
-  entity2: field22.ref(),
-  entity3: field22.ref(),
-  entity4: field22.ref(),
-  entity5: field22.ref()
+  entity1: field23.ref(),
+  entity2: field23.ref(),
+  entity3: field23.ref(),
+  entity4: field23.ref(),
+  entity5: field23.ref()
 };
 var IntersectDef = class extends CanvasSingletonDef6 {
   constructor() {
@@ -1750,30 +1779,30 @@ var Intersect = new IntersectDef();
 
 // src/singletons/Keyboard.ts
 import { CanvasSingletonDef as CanvasSingletonDef7 } from "@woven-ecs/canvas-store";
-import { field as field23 } from "@woven-ecs/core";
+import { field as field24 } from "@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: field23.buffer(field23.uint8()).size(KEY_BUFFER_SIZE),
+  keysDown: field24.buffer(field24.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: field23.buffer(field23.uint8()).size(KEY_BUFFER_SIZE),
+  keysDownTrigger: field24.buffer(field24.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: field23.buffer(field23.uint8()).size(KEY_BUFFER_SIZE),
+  keysUpTrigger: field24.buffer(field24.uint8()).size(KEY_BUFFER_SIZE),
   /** Common modifier - Shift key is down */
-  shiftDown: field23.boolean().default(false),
+  shiftDown: field24.boolean().default(false),
   /** Common modifier - Alt/Option key is down */
-  altDown: field23.boolean().default(false),
+  altDown: field24.boolean().default(false),
   /** Common modifier - Ctrl (Windows/Linux) or Cmd (Mac) is down */
-  modDown: field23.boolean().default(false)
+  modDown: field24.boolean().default(false)
 };
 function getBit(buffer, bitIndex) {
   if (bitIndex < 0 || bitIndex >= buffer.length * 8) return false;
@@ -2056,24 +2085,24 @@ var Key = {
 
 // src/singletons/Mouse.ts
 import { CanvasSingletonDef as CanvasSingletonDef8 } from "@woven-ecs/canvas-store";
-import { field as field24 } from "@woven-ecs/core";
+import { field as field25 } from "@woven-ecs/core";
 var MouseSchema = {
   /** Current mouse position relative to the editor element [x, y] */
-  position: field24.tuple(field24.float32(), 2).default([0, 0]),
+  position: field25.tuple(field25.float32(), 2).default([0, 0]),
   /** Horizontal wheel delta (positive = scroll right) */
-  wheelDeltaX: field24.float32().default(0),
+  wheelDeltaX: field25.float32().default(0),
   /** Vertical wheel delta (positive = scroll down), normalized across browsers */
-  wheelDeltaY: field24.float32().default(0),
+  wheelDeltaY: field25.float32().default(0),
   /** True for 1 frame when mouse moves */
-  moveTrigger: field24.boolean().default(false),
+  moveTrigger: field25.boolean().default(false),
   /** True for 1 frame when wheel is scrolled */
-  wheelTrigger: field24.boolean().default(false),
+  wheelTrigger: field25.boolean().default(false),
   /** True for 1 frame when mouse enters the editor element */
-  enterTrigger: field24.boolean().default(false),
+  enterTrigger: field25.boolean().default(false),
   /** True for 1 frame when mouse leaves the editor element */
-  leaveTrigger: field24.boolean().default(false),
+  leaveTrigger: field25.boolean().default(false),
   /** Whether the mouse is over a UI element (not the canvas) */
-  obscured: field24.boolean().default(false)
+  obscured: field25.boolean().default(false)
 };
 var MouseDef = class extends CanvasSingletonDef8 {
   constructor() {
@@ -2114,11 +2143,11 @@ var Mouse = new MouseDef();
 
 // src/singletons/RankBounds.ts
 import { CanvasSingletonDef as CanvasSingletonDef9 } from "@woven-ecs/canvas-store";
-import { field as field25 } from "@woven-ecs/core";
+import { field as field26 } from "@woven-ecs/core";
 import { generateJitteredKeyBetween } from "fractional-indexing-jittered";
 var RankBoundsSchema = {
-  minRank: field25.string().max(36).default(""),
-  maxRank: field25.string().max(36).default("")
+  minRank: field26.string().max(36).default(""),
+  maxRank: field26.string().max(36).default("")
 };
 var RankBoundsDef = class extends CanvasSingletonDef9 {
   constructor() {
@@ -2177,12 +2206,12 @@ var RankBounds = new RankBoundsDef();
 
 // src/singletons/ScaleWithZoomState.ts
 import { defineCanvasSingleton as defineCanvasSingleton2 } from "@woven-ecs/canvas-store";
-import { field as field26 } from "@woven-ecs/core";
+import { field as field27 } from "@woven-ecs/core";
 var ScaleWithZoomState = defineCanvasSingleton2(
   { name: "scaleWithZoomState" },
   {
     /** Last processed zoom level */
-    lastZoom: field26.float64().default(1)
+    lastZoom: field27.float64().default(1)
   }
 );
 
@@ -2195,12 +2224,12 @@ import {
   createEntity,
   defineComponent,
   defineQuery,
-  field as field27,
+  field as field28,
   getResources,
   removeEntity
 } from "@woven-ecs/core";
 var CommandMarker = defineComponent({
-  name: field27.string().max(128)
+  name: field28.string().max(128)
 });
 var editorPayloads = /* @__PURE__ */ new WeakMap();
 function getPayloadMap(ctx) {
@@ -2339,6 +2368,7 @@ function detachKeyboardListeners(domElement) {
 }
 var keyboardSystem = defineEditorSystem({ phase: "input" }, (ctx) => {
   const resources = getResources3(ctx);
+  if (!resources.domElement) return;
   const state = instanceState.get(resources.domElement);
   if (!state) return;
   on(ctx, ResetKeyboard, () => {
@@ -2440,6 +2470,7 @@ function detachMouseListeners(domElement) {
 }
 var mouseSystem = defineEditorSystem({ phase: "input" }, (ctx) => {
   const resources = getResources4(ctx);
+  if (!resources.domElement) return;
   const state = instanceState2.get(resources.domElement);
   if (!state) return;
   const currentMouse = Mouse.read(ctx);
@@ -2516,9 +2547,12 @@ function attachPointerListeners(domElement) {
       });
     },
     onContextMenu: (e) => {
+      if (e.target instanceof HTMLElement && e.target.closest('[contenteditable="true"]')) return;
       e.preventDefault();
-      const hasPointerDown = state.eventsBuffer.some((evt) => evt.type === "pointerdown");
-      if (hasPointerDown) return;
+      const hasRightButtonEvent = state.eventsBuffer.some(
+        (evt) => evt.button === 2 && (evt.type === "pointerdown" || evt.type === "pointerup")
+      );
+      if (hasRightButtonEvent) return;
       state.eventsBuffer.push({
         type: "pointerdown",
         pointerId: 0,
@@ -2588,6 +2622,7 @@ function detachPointerListeners(domElement) {
 var pointerSystem = defineEditorSystem({ phase: "input" }, (ctx) => {
   const resources = getResources5(ctx);
   const { domElement } = resources;
+  if (!domElement) return;
   const state = instanceState3.get(domElement);
   if (!state) return;
   state.frameCount++;
@@ -2667,6 +2702,7 @@ function detachScreenObserver(domElement) {
 var screenSystem = defineEditorSystem({ phase: "input" }, (ctx) => {
   const resources = getResources6(ctx);
   const { domElement } = resources;
+  if (!domElement) return;
   const state = instanceState4.get(domElement);
   if (!state) return;
   const frame = Frame.read(ctx);
@@ -2693,6 +2729,7 @@ function getCursorSvg(cursors, kind, rotateZ) {
   return `url("data:image/svg+xml,${encodeURIComponent(svg.trim())}") ${def.hotspot[0]} ${def.hotspot[1]}, auto`;
 }
 var cursorSystem = defineEditorSystem({ phase: "render", priority: -100 }, (ctx) => {
+  if (typeof document === "undefined") return;
   const changedCursors = cursorQuery.changed(ctx);
   const frame = Frame.read(ctx);
   if (changedCursors.length === 0 && frame.number !== 1) {
@@ -2724,8 +2761,8 @@ function getBlockDef(ctx, tag) {
 function canBlockEdit(ctx, tag) {
   return getBlockDef(ctx, tag).editOptions.canEdit;
 }
-function canBlockSelect(ctx, tag) {
-  return getBlockDef(ctx, tag).selectable;
+function canBlockInteract(ctx, tag) {
+  return getBlockDef(ctx, tag).interactable;
 }
 function getBlockResizeMode(ctx, entityId) {
   const block = Block.read(ctx, entityId);
@@ -2749,6 +2786,136 @@ function computeAabb(ctx, entityId, out) {
   }
 }
 
+// src/helpers/embed.ts
+function detectEmbedProvider(url) {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname.replace(/^www\./, "");
+    if (host === "youtube.com" || host === "youtu.be") return "youtube" /* Youtube */;
+    if (host === "open.spotify.com" || host === "spotify.com") return "spotify" /* Spotify */;
+    if (host === "google.com" && parsed.pathname.startsWith("/maps")) return "google-maps" /* GoogleMaps */;
+    if (host === "maps.google.com") return "google-maps" /* GoogleMaps */;
+    if (host === "calendar.google.com") return "google-calendar" /* GoogleCalendar */;
+    if (host === "docs.google.com" && parsed.pathname.includes("/presentation")) return "google-slides" /* GoogleSlides */;
+    if (host === "figma.com" || host.endsWith(".figma.com")) return "figma" /* Figma */;
+    if (host === "gist.github.com") return "github-gist" /* GithubGist */;
+    if (host === "tldraw.com" || host.endsWith(".tldraw.com")) return "tldraw" /* Tldraw */;
+    return "unknown" /* Unknown */;
+  } catch {
+    return "unknown" /* Unknown */;
+  }
+}
+function validateEmbedUrl(url, provider) {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname.replace(/^www\./, "");
+    switch (provider) {
+      case "youtube" /* Youtube */: {
+        if (host === "youtu.be") return null;
+        if (host !== "youtube.com") return "URL must be from youtube.com";
+        if (parsed.pathname === "/watch" && parsed.searchParams.has("v")) return null;
+        if (parsed.pathname.startsWith("/embed/")) return null;
+        return "Paste a YouTube video link (e.g. youtube.com/watch?v=...)";
+      }
+      case "spotify" /* Spotify */: {
+        if (host !== "open.spotify.com" && host !== "spotify.com") return "URL must be from open.spotify.com";
+        if (parsed.pathname.length <= 1) return "Paste a Spotify track, album, or playlist link";
+        return null;
+      }
+      case "google-maps" /* GoogleMaps */: {
+        if (host !== "google.com" && host !== "maps.google.com") return "URL must be from google.com/maps";
+        if (!parsed.pathname.startsWith("/maps") && host !== "maps.google.com") return "Paste a Google Maps link";
+        return null;
+      }
+      case "google-calendar" /* GoogleCalendar */: {
+        if (host !== "calendar.google.com") return "URL must be from calendar.google.com";
+        return null;
+      }
+      case "google-slides" /* GoogleSlides */: {
+        if (host !== "docs.google.com") return "URL must be from docs.google.com";
+        if (!parsed.pathname.includes("/presentation/")) return "Paste a Google Slides presentation link";
+        return null;
+      }
+      case "figma" /* Figma */: {
+        if (host !== "figma.com" && !host.endsWith(".figma.com")) return "URL must be from figma.com";
+        return null;
+      }
+      case "github-gist" /* GithubGist */: {
+        if (host !== "gist.github.com") return "URL must be from gist.github.com";
+        return null;
+      }
+      case "tldraw" /* Tldraw */: {
+        if (host !== "tldraw.com" && !host.endsWith(".tldraw.com")) return "URL must be from tldraw.com";
+        return null;
+      }
+      default:
+        return null;
+    }
+  } catch {
+    return "Please enter a valid URL";
+  }
+}
+function resolveEmbedUrl(url, provider) {
+  const p = provider ?? detectEmbedProvider(url);
+  try {
+    const parsed = new URL(url);
+    switch (p) {
+      case "youtube" /* Youtube */: {
+        const host = parsed.hostname.replace(/^www\./, "");
+        if (host === "youtu.be") {
+          const videoId2 = parsed.pathname.slice(1);
+          return `https://www.youtube.com/embed/${videoId2}`;
+        }
+        const videoId = parsed.searchParams.get("v");
+        if (videoId && parsed.pathname === "/watch") {
+          return `https://www.youtube.com/embed/${videoId}`;
+        }
+        return url;
+      }
+      case "spotify" /* Spotify */: {
+        if (!parsed.pathname.startsWith("/embed/")) {
+          return `https://open.spotify.com/embed${parsed.pathname}`;
+        }
+        return url;
+      }
+      case "google-maps" /* GoogleMaps */: {
+        if (parsed.pathname.startsWith("/maps/embed")) return url;
+        if (parsed.searchParams.get("output") === "embed") return url;
+        const placeMatch = parsed.pathname.match(/\/maps\/place\/([^/]+)/);
+        if (placeMatch) {
+          return `https://www.google.com/maps?q=${encodeURIComponent(decodeURIComponent(placeMatch[1]))}&output=embed`;
+        }
+        const q = parsed.searchParams.get("q");
+        if (q) {
+          return `https://www.google.com/maps?q=${encodeURIComponent(q)}&output=embed`;
+        }
+        const atMatch = parsed.pathname.match(/\/@(-?[\d.]+),(-?[\d.]+),(\d+\.?\d*)z/);
+        if (atMatch) {
+          const [, lat, lng, zoom] = atMatch;
+          return `https://www.google.com/maps?q=${lat},${lng}&z=${Math.round(parseFloat(zoom))}&output=embed`;
+        }
+        return `https://www.google.com/maps?q=${encodeURIComponent(url)}&output=embed`;
+      }
+      case "google-slides" /* GoogleSlides */: {
+        return url.replace(/\/(edit|pub)(#.*)?(\?.*)?$/, "/embed");
+      }
+      case "figma" /* Figma */: {
+        return `https://www.figma.com/embed?embed_host=share&url=${encodeURIComponent(url)}`;
+      }
+      case "github-gist" /* GithubGist */: {
+        if (!url.endsWith(".pibb")) {
+          return `${url}.pibb`;
+        }
+        return url;
+      }
+      default:
+        return url;
+    }
+  } catch {
+    return url;
+  }
+}
+
 // src/helpers/held.ts
 import { getResources as getResources9, hasComponent as hasComponent2 } from "@woven-ecs/core";
 function isHeldByRemote(ctx, entityId) {
@@ -2991,6 +3158,10 @@ var intersectSystem = defineEditorSystem({ phase: "capture", priority: 100 }, (c
     changed.add(entityId);
   }
   for (const entityId of added) {
+    if (hasComponent5(ctx, entityId, Block)) {
+      const block = Block.read(ctx, entityId);
+      if (!canBlockInteract(ctx, block.tag)) continue;
+    }
     if (!hasComponent5(ctx, entityId, Aabb)) {
       addComponent4(ctx, entityId, Aabb, { value: [0, 0, 0, 0] });
     }
@@ -2998,6 +3169,7 @@ var intersectSystem = defineEditorSystem({ phase: "capture", priority: 100 }, (c
     computeAabb(ctx, entityId, aabb.value);
   }
   for (const entityId of changed) {
+    if (!hasComponent5(ctx, entityId, Aabb)) continue;
     const aabb = Aabb.write(ctx, entityId);
     computeAabb(ctx, entityId, aabb.value);
   }
@@ -3018,9 +3190,11 @@ var intersectSystem = defineEditorSystem({ phase: "capture", priority: 100 }, (c
   }
   const resources = getResources11(ctx);
   const isObscured = Mouse.isObscured(ctx);
-  const wasObscured = prevObscuredByElement.get(resources.domElement) ?? false;
+  const wasObscured = resources.domElement ? prevObscuredByElement.get(resources.domElement) ?? false : false;
   const obscuredChanged = isObscured !== wasObscured;
-  prevObscuredByElement.set(resources.domElement, isObscured);
+  if (resources.domElement) {
+    prevObscuredByElement.set(resources.domElement, isObscured);
+  }
   if (isObscured) {
     clearHovered(ctx);
     return;
@@ -3107,6 +3281,7 @@ import { defineQuery as defineQuery9 } from "@woven-ecs/core";
 var scaleWithZoomQuery = defineQuery9((q) => q.with(Block).tracking(ScaleWithZoom));
 var _scaledSize = [0, 0];
 var _anchorOffset = [0, 0];
+var _anchorAdj = [0, 0];
 var scaleWithZoomSystem = defineEditorSystem({ phase: "render", priority: 100 }, (ctx) => {
   const camera = Camera.read(ctx);
   const state = ScaleWithZoomState.read(ctx);
@@ -3131,7 +3306,15 @@ function scaleBlock(ctx, entityId, zoom) {
   _scaledSize[1] = swz.startSize[1] * scaleY;
   Vec22.copy(_anchorOffset, swz.startSize);
   Vec22.sub(_anchorOffset, _scaledSize);
-  Vec22.multiply(_anchorOffset, swz.anchor);
+  if (block.rotateZ !== 0) {
+    _anchorAdj[0] = _anchorOffset[0] * (swz.anchor[0] - 0.5);
+    _anchorAdj[1] = _anchorOffset[1] * (swz.anchor[1] - 0.5);
+    Vec22.rotate(_anchorAdj, block.rotateZ);
+    _anchorOffset[0] = _anchorOffset[0] * 0.5 + _anchorAdj[0];
+    _anchorOffset[1] = _anchorOffset[1] * 0.5 + _anchorAdj[1];
+  } else {
+    Vec22.multiply(_anchorOffset, swz.anchor);
+  }
   Vec22.copy(block.position, swz.startPosition);
   Vec22.add(block.position, _anchorOffset);
   Vec22.copy(block.size, _scaledSize);
@@ -3171,6 +3354,14 @@ var CorePlugin = {
       editOptions: {
         canEdit: true
       }
+    },
+    {
+      tag: "embed",
+      components: [Embed],
+      resizeMode: ResizeMode.Free,
+      editOptions: {
+        canEdit: true
+      }
     }
   ],
   systems: [
@@ -3199,6 +3390,7 @@ var CorePlugin = {
   ],
   setup(ctx) {
     const { domElement } = getResources12(ctx);
+    if (!domElement) return;
     attachKeyboardListeners(domElement);
     attachMouseListeners(domElement);
     attachScreenObserver(domElement);
@@ -3206,6 +3398,7 @@ var CorePlugin = {
   },
   teardown(ctx) {
     const { domElement } = getResources12(ctx);
+    if (!domElement) return;
     detachKeyboardListeners(domElement);
     detachMouseListeners(domElement);
     detachScreenObserver(domElement);
@@ -3306,6 +3499,9 @@ var FontLoader = class {
    */
   loadSingleFont(family) {
     this.loadedFonts.add(family.name);
+    if (typeof document === "undefined") {
+      return Promise.resolve();
+    }
     return new Promise((resolve, reject) => {
       const link = document.createElement("link");
       link.rel = "stylesheet";
@@ -3684,11 +3880,54 @@ var Editor = class {
   _getContext() {
     return this.ctx;
   }
+  /**
+   * Attach a DOM element to a headless editor.
+   * Use this after SSR to connect input listeners and enable rendering.
+   *
+   * @param domElement - The DOM element to attach to
+   *
+   * @example
+   * ```typescript
+   * // SSR: create headless editor
+   * const editor = new Editor(null, { plugins: [...] });
+   * await editor.initialize();
+   * editor.tick(); // process initial state
+   *
+   * // Client hydration: attach the DOM
+   * editor.attachDom(document.getElementById('canvas')!);
+   * ```
+   */
+  attachDom(domElement) {
+    const resources = this.ctx.resources;
+    if (resources.domElement) {
+      throw new Error("Editor already has a DOM element attached. Call detachDom() first.");
+    }
+    resources.domElement = domElement;
+    attachKeyboardListeners(domElement);
+    attachMouseListeners(domElement);
+    attachScreenObserver(domElement);
+    attachPointerListeners(domElement);
+  }
+  /**
+   * Detach the current DOM element.
+   * Removes all input listeners. The editor continues to run headless.
+   */
+  detachDom() {
+    const resources = this.ctx.resources;
+    const { domElement } = resources;
+    if (!domElement) return;
+    detachKeyboardListeners(domElement);
+    detachMouseListeners(domElement);
+    detachScreenObserver(domElement);
+    detachPointerListeners(domElement);
+    resources.domElement = null;
+  }
   /**
    * Clean up the editor.
    * Call this when done to release resources.
    */
   dispose() {
+    this.detachDom();
     const plugins = Array.from(this.plugins.values()).reverse();
     for (const plugin of plugins) {
       if (plugin.teardown) {
@@ -4005,6 +4244,8 @@ export {
   Edited,
   Editor,
   EditorStateDef,
+  Embed,
+  EmbedProvider,
   EventType,
   FontFamily,
   FontLoader,
@@ -4050,17 +4291,18 @@ export {
   VerticalAlignment,
   addComponent6 as addComponent,
   canBlockEdit,
-  canBlockSelect,
+  canBlockInteract,
   clearPointerTrackingState,
   createEntity5 as createEntity,
-  defineCanvasComponent13 as defineCanvasComponent,
+  defineCanvasComponent14 as defineCanvasComponent,
   defineCanvasSingleton3 as defineCanvasSingleton,
   defineCommand,
   defineEditorState,
   defineEditorSystem,
   defineQuery11 as defineQuery,
   defineSystem,
-  field28 as field,
+  detectEmbedProvider,
+  field29 as field,
   getBackrefs,
   getBlockDef,
   getBlockResizeMode,
@@ -4081,6 +4323,8 @@ export {
   parsePlugin,
   removeComponent2 as removeComponent,
   removeEntity3 as removeEntity,
-  runMachine
+  resolveEmbedUrl,
+  runMachine,
+  validateEmbedUrl
 };
 //# sourceMappingURL=index.js.map