@oh-just-another/scene 0.57.0

package/dist/constants.js

@@ -0,0 +1,186 @@
+/**
+ * Tunable thresholds for the scene-level helpers (snap engine, hit-test
+ * cheap-cull). Keep magic numbers here so hosts can re-tune the engine
+ * without touching the algorithm code.
+ */
+/**
+ * Half-side of the bounding box used by `isProbeNearElement` to cheap-cull
+ * snap candidates. Shapes farther than this from the probe (plus the
+ * snap threshold cushion) are skipped without the full anchor walk.
+ *
+ * The default of 1000 world units covers any typical editor shape; bump
+ * it if hosts work with very large diagrams where the cheap-cull starts
+ * to over-prune real candidates.
+ */
+export const SNAP_PROBE_CULL_RADIUS = 1000;
+/**
+ * Fallback grid spacing (world units) used by snap-to-grid when the
+ * viewport has no `gridSize` (grid hidden) but snapping is still on.
+ * Lets the user keep clean grid-aligned geometry without a visible
+ * grid. Matches the app's default `gridSize` of 20. Range: 4–64.
+ */
+export const DEFAULT_GRID_SPACING = 20;
+/**
+ * Padding (world units) the elbow router inflates obstacle bboxes
+ * by before searching. Larger values keep edges visibly clear of
+ * shapes; smaller values let the router squeeze through tight
+ * spaces. 20 px matches the gridSize default for diagrams that
+ * snap to a 20-unit grid.
+ */
+export const ELBOW_OBSTACLE_MARGIN = 20;
+/**
+ * Epsilon used to decide whether an axis-aligned segment runs
+ * *along* an obstacle boundary (allowed) or *through* it (blocked).
+ * A degenerate small value catches floating-point fuzz from
+ * `inflate` arithmetic without admitting real crossings.
+ */
+export const ELBOW_OBSTACLE_INTERIOR_EPSILON = 0.5;
+/**
+ * Per-turn cost added in the elbow A* so the router minimises BENDS first,
+ * distance second (lexicographic — far larger than any plausible canvas
+ * distance). Keeps routes stable: small shape moves no longer flip between
+ * equal-distance alternatives, and the path takes the fewest corners.
+ */
+export const ELBOW_BEND_PENALTY = 100000;
+/**
+ * Hysteresis band (world px) for the C-wrap side choice in `wrapRoute`.
+ * When the connector must wrap around the union of its two bound shapes,
+ * the over/under (or left/right) side is picked from the endpoints'
+ * midpoint vs the union centre. Within this band of the centre the
+ * previous side is kept (read from `edge.routedPoints`), so a small
+ * back-and-forth drag doesn't thrash; the side only switches once the
+ * midpoint moves this far past the centre. Larger = stickier.
+ * Range: 8–48.
+ */
+export const ELBOW_WRAP_HYSTERESIS = 24;
+/**
+ * Perf cap for "avoid obstacles" routing. The A* grid scales with the
+ * number of obstacle corners, and the route is recomputed every frame
+ * while a shape is dragged, so above this many scene shapes we skip
+ * whole-scene avoidance and fall back to the cheap two-box elbow (the
+ * link still keeps clear of its own ends). Range: 60–300.
+ */
+export const ELBOW_AVOID_MAX_OBSTACLES = 150;
+/**
+ * Length (world px) of the fixed, non-movable terminal segment an elbow
+ * connector always leaves at each end before its first bend — the endpoint
+ * is pushed out this far along its exit heading so the connector departs/
+ * arrives perpendicular to the edge and there's buffer room to draw the
+ * arrowhead. Must stay ≥ ELBOW_OBSTACLE_MARGIN so the pushed-out point
+ * sits outside the inflated obstacle the A* router avoids. Larger → more
+ * breathing room before the first bend. Range: 16–40.
+ */
+export const ELBOW_TERMINAL_BUFFER = 30;
+/**
+ * --- Self-loop connectors (a link whose both ends bind to the SAME element) ---
+ *
+ * A self-loop is routed OUTSIDE the element so it reads as a loop/arc instead of
+ * a flat line on (or across) the shape.
+ *
+ * - `SELF_LOOP_SIZE` — how far (world px) the loop bows out past the element's
+ *   edge. Fixed for every element. Range: 24–80.
+ * - `SELF_LOOP_SPREAD` — when both ends resolve to the SAME point (centre /
+ *   floating / same anchor) the two exit points are spread this far apart along
+ *   the edge so the loop has width. Clamped to a third of the side. Range: 12–40.
+ * - `SELF_LOOP_CURVE_ARM_FACTOR` — control-arm length for a curved self-loop as a
+ *   multiple of `SELF_LOOP_SIZE`; larger = rounder, more pronounced arc. 2.2
+ *   gives a clean teardrop. Range: 1.5–3.
+ */
+export const SELF_LOOP_SIZE = 40;
+export const SELF_LOOP_SPREAD = 24;
+export const SELF_LOOP_CURVE_ARM_FACTOR = 2.2;
+/**
+ * Clearance (world px) a candidate centred path (the "thread"/mid-S or the
+ * C-wrap) must keep from a bound shape's interior before it counts as CROSSING
+ * it. This is the threshold that decides thread-vs-wrap-vs-A*: a larger value
+ * makes the router bail off the direct/centred path sooner (route stays further
+ * from shapes), a smaller value lets it skim closer to an edge before detouring.
+ * At 1 px it only rejects genuine interior crossings, allowing edge-grazing.
+ * Range: 1–8.
+ */
+export const ELBOW_OBSTACLE_CLEARANCE = 1;
+/**
+ * Parametric step used to sample each segment of a candidate path when testing
+ * whether it crosses a shape (`pathCrossesObstacle`). Smaller = finer (catches
+ * a narrow shape a coarse sampling would skip) at more cost; 0.1 samples 11
+ * points per segment, enough for typical shape sizes. Range: 0.02–0.2.
+ */
+export const ELBOW_CROSS_SAMPLE_STEP = 0.1;
+/**
+ * --- Curved (bezier) link geometry ---
+ *
+ * Shared by the renderer (draws cubic beziers), hit-testing and bounds
+ * (flatten the same curve) so the visible curve and the clickable curve
+ * agree. Lives in scene so lower layers own the geometry; renderer-core
+ * imports it.
+ *
+ * - `CURVE_CATMULL_TENSION` — divisor for the Catmull-Rom tangents in the
+ *   spline→bezier conversion (waypointed curves). 6 is canonical uniform
+ *   Catmull-Rom (control point = P + (Pnext − Pprev) / 6). Larger → tighter;
+ *   smaller → looser. Range: 4–8.
+ * - `CURVE_END_TANGENT_RATIO` — for a no-waypoint span the cubic's control
+ *   arms leave/enter the endpoints along their edge normals with length =
+ *   this fraction of the endpoint distance, so the connector exits/enters
+ *   perpendicular to the element edge (flowchart look). Larger → rounder /
+ *   more pronounced. Range: 0.25–0.6.
+ * - `CURVE_END_TANGENT_MAX_PX` — caps that control-arm length (world px) so a
+ *   long link doesn't over-bow. Range: 60–160.
+ * - `CURVE_FLATTEN_SEGMENTS` — samples per cubic when flattening the curve
+ *   for hit-testing / bounds. Higher = closer to the drawn curve. Range:
+ *   8–24.
+ */
+export const CURVE_CATMULL_TENSION = 6;
+export const CURVE_END_TANGENT_RATIO = 0.8;
+export const CURVE_END_TANGENT_MAX_PX = 240;
+export const CURVE_FLATTEN_SEGMENTS = 16;
+/**
+ * --- Roundness (Style.roundness) ---
+ *
+ * Adaptive radius: pick a fixed radius for shapes bigger than the cutoff,
+ * scale proportionally for smaller ones so the corner doesn't dominate.
+ * 32 px / 0.25 looks rounded without becoming a capsule across the
+ * realistic shape-size range.
+ */
+/** Fixed pixel radius used by adaptive rounding for shapes ≥ cutoff. */
+export const ADAPTIVE_CORNER_RADIUS = 32;
+/**
+ * Proportional radius (0..1 of the smaller side) used by adaptive
+ * rounding for shapes below the cutoff, and the fall-through when
+ * `Roundness.value` is omitted but the type is `round`.
+ */
+export const PROPORTIONAL_CORNER_RADIUS = 0.25;
+/**
+ * --- Text bounds estimation ---
+ *
+ * The text bounder has no layout engine, so it approximates the box.
+ * Renderers compute the precise layout (via `measureText`) during
+ * draw / caret positioning; these factors only drive selection bbox
+ * and resize-handle placement, where a rough estimate is fine.
+ *
+ * - `TEXT_APPROX_CHAR_WIDTH_FACTOR` — average glyph advance as a
+ *   fraction of font size (~0.6 for proportional Latin text).
+ * - `TEXT_LINE_HEIGHT_FACTOR` — line height as a multiple of font
+ *   size. Must match the renderer's `DEFAULT_LINE_HEIGHT_FACTOR`.
+ */
+export const TEXT_APPROX_CHAR_WIDTH_FACTOR = 0.6;
+export const TEXT_LINE_HEIGHT_FACTOR = 1.2;
+/**
+ * --- Frame header (label strip) geometry ---
+ *
+ * The frame's name is drawn in a strip ABOVE the frame body (local y in
+ * `[-FRAME_HEADER_HEIGHT, 0]`). Shared by the renderer (draws it), the
+ * editor (header double-click → rename hit zone + render overflow) and
+ * react-ui (positions the inline name editor) so all three agree.
+ *
+ * - `FRAME_HEADER_HEIGHT` — strip height (world px).
+ * - `FRAME_HEADER_PADDING_X` — horizontal text inset, each side (world px).
+ * - `FRAME_HEADER_FONT_SIZE` — label font size (world px).
+ *
+ * The strip width is dynamic: it hugs the label width but is capped at the
+ * frame's own width (a too-long name is ellipsised) — computed in the
+ * renderer, which can measure text.
+ */
+export const FRAME_HEADER_HEIGHT = 24;
+export const FRAME_HEADER_PADDING_X = 8;
+export const FRAME_HEADER_FONT_SIZE = 12;
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAG,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC;AAEzC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAE7C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAC;AACjC,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AACvC,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAC3C,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,CAAC;AAC5C,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAEzC;;;;;;;GAOG;AAEH,wEAAwE;AACxE,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAEzC;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAI,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAG,CAAC;AACjD,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AACtC,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AACxC,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC"}

package/dist/container.d.ts

@@ -0,0 +1,112 @@
+import type { Bounds, ElementId, Vec2 } from "@oh-just-another/types";
+import type { Scene } from "./scene.js";
+import type { Element, ElementBase } from "./shape.js";
+/**
+ * Container behaviour spec. Carried on a shape via
+ * `shape.metadata.container`. Any shape marked with this object becomes
+ * a container: a dragged child landing in its drop-zone is attached via
+ * `parentId`, moving the container moves children in lockstep, and a
+ * drop expands the container if the child goes past the zone.
+ *
+ * `dropZone` is stored in local coordinates (relative to
+ * `shape.position`). The helpers below convert to world and back.
+ *
+ * `padding` is the inset for auto-grow expansion: when the zone grows,
+ * the new edge is added with this margin.
+ */
+export interface ContainerSpec {
+    readonly dropZone: Bounds;
+    readonly padding?: number;
+}
+/**
+ * Live resolver that computes the current `ContainerSpec` for a shape
+ * — typically by re-running the template's layout against its current
+ * `width` / `height` so the drop-zone stays in sync after the user
+ * resizes the container. Returns `null` when the resolver doesn't
+ * handle this shape; the next resolver in the chain (or the static
+ * `metadata.container` fallback) is tried.
+ *
+ * Registered by `@templates` so kernel packages stay UI-agnostic.
+ */
+export type ContainerResolver = (shape: ElementBase) => ContainerSpec | null;
+/**
+ * Plug in a resolver. Called in registration order — first non-null
+ * wins. Idempotent: a duplicate function reference is ignored so
+ * hot-reload doesn't double-register.
+ */
+export declare const registerContainerResolver: (resolver: ContainerResolver) => void;
+/** True when a shape is declared a container — via resolver or metadata. */
+export declare const isContainer: (s: ElementBase) => boolean;
+/**
+ * Resolve the current `ContainerSpec` for `s`. Tries every registered
+ * resolver first (live, layout-aware path for rich templates); then
+ * synthesises a live drop-zone for any shape carrying
+ * `metadata.autoLayout` + a `width`/`height` field — its zone is
+ * always `(padding, padding, width - 2*padding, height - 2*padding)`,
+ * which keeps the area in sync with the shape after a manual resize
+ * (no stale stored offsets); finally falls back to a fully static
+ * `metadata.container` spec for hand-authored containers. Returns
+ * `null` when the shape is not a container.
+ */
+export declare const getContainerSpec: (s: ElementBase) => ContainerSpec | null;
+/**
+ * World-coord drop-zone rect for the given container shape. Returns
+ * `null` when the shape is not a container.
+ */
+export declare const getDropZoneWorld: (s: ElementBase) => Bounds | null;
+/**
+ * Resolver returning EVERY drop-zone of a shape in local coords (relative
+ * to `shape.position`) — e.g. each lane of a multi-lane swim-lane. Distinct
+ * from `ContainerResolver`, which collapses to the single attach zone. Return
+ * `null` to defer to the next resolver. Registered by `@templates`.
+ */
+export type ContainerZonesResolver = (shape: ElementBase) => readonly Bounds[] | null;
+/** Plug in a multi-zone resolver. First non-null wins; idempotent. */
+export declare const registerContainerZonesResolver: (resolver: ContainerZonesResolver) => void;
+/**
+ * ALL drop-zones of `s` in world coords — every lane of a multi-lane
+ * container, not just the single attach zone. Tries the multi-zone resolvers
+ * first; falls back to the single `getDropZoneWorld` (wrapped) so non-template
+ * containers still report their one zone. Returns `[]` when the shape is not a
+ * container. Introspection only — the attach protocol uses the single-zone
+ * path (`getDropZoneWorld` / `findContainerAt`).
+ */
+export declare const getDropZonesWorld: (s: ElementBase) => readonly Bounds[];
+/**
+ * Topmost container shape whose drop-zone contains `worldPoint`.
+ * Walks layers top-down + shapes within layer top-down so the visually
+ * topmost container wins. `exclude` lets the caller skip shapes being
+ * dragged (a container can't drop onto itself / its own children).
+ *
+ * Nested containers: returns the innermost match — the deepest
+ * container whose dropZone contains the point.
+ */
+export declare const findContainerAt: (scene: Scene, worldPoint: Vec2, exclude?: ReadonlySet<ElementId>) => Element | null;
+/**
+ * Compute the new local-space drop-zone bounds that fit `childWorld`.
+ * Returns `null` when the child is already internal — no change needed.
+ *
+ * The returned rect is in local coordinates (relative to
+ * `shape.position`), suitable to write back into `metadata.container`.
+ * Padding inflates the new edge but is never subtracted from existing
+ * edges — the zone only grows, never shrinks.
+ */
+export declare const expandDropZoneToFit: (container: ElementBase, childWorld: Bounds) => Bounds | null;
+/**
+ * Required shape-level `width` / `height` (when present) that match
+ * the new local drop-zone. Used by the editor after `expandDropZoneToFit`
+ * to sync the container's visual with the expanded zone.
+ * Preserves the existing dropZone offset within the shape — if the
+ * dropZone didn't start at (0,0), the shape grows by exactly the amount
+ * added to the dropZone, without shifting the offset.
+ */
+export declare const containerSizeForZone: (current: {
+    width: number;
+    height: number;
+    spec: ContainerSpec;
+}, nextZone: Bounds) => {
+    width: number;
+    height: number;
+    positionOffset: Vec2;
+};
+//# sourceMappingURL=container.d.ts.map

package/dist/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../src/container.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAEtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGvD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,aAAa,GAAG,IAAI,CAAC;AAI7E;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GAAI,UAAU,iBAAiB,KAAG,IAEvE,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,WAAW,GAAI,GAAG,WAAW,KAAG,OAAuC,CAAC;AAErF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,WAAW,KAAG,aAAa,GAAG,IA4CjE,CAAC;AAYF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,WAAW,KAAG,MAAM,GAAG,IAS1D,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;AAItF,sEAAsE;AACtE,eAAO,MAAM,8BAA8B,GAAI,UAAU,sBAAsB,KAAG,IAEjF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAAI,GAAG,WAAW,KAAG,SAAS,MAAM,EAcjE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,KAAK,EACZ,YAAY,IAAI,EAChB,UAAS,WAAW,CAAC,SAAS,CAAa,KAC1C,OAAO,GAAG,IAgBZ,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAC9B,WAAW,WAAW,EACtB,YAAY,MAAM,KACjB,MAAM,GAAG,IAuCX,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,aAAa,CAAA;CAAE,EAC/D,UAAU,MAAM,KACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,IAAI,CAAA;CAcvD,CAAC"}

package/dist/container.js

@@ -0,0 +1,227 @@
+import { bounds as B } from "@oh-just-another/math";
+import { getLayersInOrder, getElementsInLayer } from "./queries.js";
+const resolvers = [];
+/**
+ * Plug in a resolver. Called in registration order — first non-null
+ * wins. Idempotent: a duplicate function reference is ignored so
+ * hot-reload doesn't double-register.
+ */
+export const registerContainerResolver = (resolver) => {
+    if (!resolvers.includes(resolver))
+        resolvers.push(resolver);
+};
+/** True when a shape is declared a container — via resolver or metadata. */
+export const isContainer = (s) => getContainerSpec(s) !== null;
+/**
+ * Resolve the current `ContainerSpec` for `s`. Tries every registered
+ * resolver first (live, layout-aware path for rich templates); then
+ * synthesises a live drop-zone for any shape carrying
+ * `metadata.autoLayout` + a `width`/`height` field — its zone is
+ * always `(padding, padding, width - 2*padding, height - 2*padding)`,
+ * which keeps the area in sync with the shape after a manual resize
+ * (no stale stored offsets); finally falls back to a fully static
+ * `metadata.container` spec for hand-authored containers. Returns
+ * `null` when the shape is not a container.
+ */
+export const getContainerSpec = (s) => {
+    for (const resolver of resolvers) {
+        const spec = resolver(s);
+        if (spec)
+            return spec;
+    }
+    // Synthesise a live drop-zone for auto-layout shapes (layout.auto-grid,
+    // layout.auto-stack, etc.). Source of truth is shape.width/height +
+    // padding — `metadata.container.dropZone`, if present, is treated as
+    // initial/serialised fallback only. Otherwise a resize of the frame
+    // wouldn't grow the drop-area (stored zone stays e.g. 296×176 even
+    // after the rectangle becomes 500×300).
+    const meta = s.metadata;
+    // ElementBase doesn't carry width/height (text / path / freedraw
+    // shapes lack them); detect through a type-erased probe rather
+    // than narrowing through TS overloads.
+    const sized = s;
+    if (meta?.autoLayout != null &&
+        typeof sized.width === "number" &&
+        typeof sized.height === "number") {
+        const padding = meta.container?.padding ?? AUTO_LAYOUT_DEFAULT_PADDING;
+        const w = sized.width;
+        const h = sized.height;
+        return {
+            dropZone: {
+                x: padding,
+                y: padding,
+                width: Math.max(0, w - 2 * padding),
+                height: Math.max(0, h - 2 * padding),
+            },
+            padding,
+        };
+    }
+    const m = s.metadata?.container;
+    if (!m || typeof m !== "object")
+        return null;
+    const obj = m;
+    if (!obj.dropZone)
+        return null;
+    const spec = obj.padding !== undefined
+        ? { dropZone: obj.dropZone, padding: obj.padding }
+        : { dropZone: obj.dropZone };
+    return spec;
+};
+/**
+ * Default symmetric inset (in world units) used by the auto-layout
+ * drop-zone synthesiser when the shape doesn't carry an explicit
+ * `metadata.container.padding`. Zero by default — a "raw" auto-layout
+ * shape places its first child at its own top-left corner. Templates
+ * (layout.auto-grid / layout.auto-stack) opt into a visible inset via
+ * `metadata.container.padding`.
+ */
+const AUTO_LAYOUT_DEFAULT_PADDING = 0;
+/**
+ * World-coord drop-zone rect for the given container shape. Returns
+ * `null` when the shape is not a container.
+ */
+export const getDropZoneWorld = (s) => {
+    const spec = getContainerSpec(s);
+    if (!spec)
+        return null;
+    return {
+        x: s.position.x + spec.dropZone.x,
+        y: s.position.y + spec.dropZone.y,
+        width: spec.dropZone.width,
+        height: spec.dropZone.height,
+    };
+};
+const zonesResolvers = [];
+/** Plug in a multi-zone resolver. First non-null wins; idempotent. */
+export const registerContainerZonesResolver = (resolver) => {
+    if (!zonesResolvers.includes(resolver))
+        zonesResolvers.push(resolver);
+};
+/**
+ * ALL drop-zones of `s` in world coords — every lane of a multi-lane
+ * container, not just the single attach zone. Tries the multi-zone resolvers
+ * first; falls back to the single `getDropZoneWorld` (wrapped) so non-template
+ * containers still report their one zone. Returns `[]` when the shape is not a
+ * container. Introspection only — the attach protocol uses the single-zone
+ * path (`getDropZoneWorld` / `findContainerAt`).
+ */
+export const getDropZonesWorld = (s) => {
+    for (const resolver of zonesResolvers) {
+        const local = resolver(s);
+        if (local) {
+            return local.map((z) => ({
+                x: s.position.x + z.x,
+                y: s.position.y + z.y,
+                width: z.width,
+                height: z.height,
+            }));
+        }
+    }
+    const single = getDropZoneWorld(s);
+    return single ? [single] : [];
+};
+/**
+ * Topmost container shape whose drop-zone contains `worldPoint`.
+ * Walks layers top-down + shapes within layer top-down so the visually
+ * topmost container wins. `exclude` lets the caller skip shapes being
+ * dragged (a container can't drop onto itself / its own children).
+ *
+ * Nested containers: returns the innermost match — the deepest
+ * container whose dropZone contains the point.
+ */
+export const findContainerAt = (scene, worldPoint, exclude = new Set()) => {
+    const layers = getLayersInOrder(scene);
+    for (let i = layers.length - 1; i >= 0; i--) {
+        const layer = layers[i];
+        if (!layer?.visible)
+            continue;
+        const shapes = getElementsInLayer(scene, layer.id);
+        for (let j = shapes.length - 1; j >= 0; j--) {
+            const s = shapes[j];
+            if (s === undefined)
+                continue;
+            if (exclude.has(s.id))
+                continue;
+            const zone = getDropZoneWorld(s);
+            if (!zone)
+                continue;
+            if (B.contains(zone, worldPoint))
+                return s;
+        }
+    }
+    return null;
+};
+/**
+ * Compute the new local-space drop-zone bounds that fit `childWorld`.
+ * Returns `null` when the child is already internal — no change needed.
+ *
+ * The returned rect is in local coordinates (relative to
+ * `shape.position`), suitable to write back into `metadata.container`.
+ * Padding inflates the new edge but is never subtracted from existing
+ * edges — the zone only grows, never shrinks.
+ */
+export const expandDropZoneToFit = (container, childWorld) => {
+    const spec = getContainerSpec(container);
+    if (!spec)
+        return null;
+    const padding = spec.padding ?? 0;
+    // Convert child world to container-local.
+    const childLocal = {
+        x: childWorld.x - container.position.x,
+        y: childWorld.y - container.position.y,
+        width: childWorld.width,
+        height: childWorld.height,
+    };
+    const z = spec.dropZone;
+    const cl = childLocal.x;
+    const ct = childLocal.y;
+    const cr = childLocal.x + childLocal.width;
+    const cb = childLocal.y + childLocal.height;
+    const zl = z.x;
+    const zt = z.y;
+    const zr = z.x + z.width;
+    const zb = z.y + z.height;
+    // Padding inflates ONLY the edge that the child crossed. A child
+    // resting exactly on an existing edge (`cl === zl`, common because
+    // `runAutoLayout` places the first child at the drop-zone's
+    // top-left corner) doesn't trigger expansion — without this guard
+    // every layout pass would shift the zone outward by `padding`,
+    // moving the container on every add and on every page reload.
+    const newMinX = cl < zl ? cl - padding : zl;
+    const newMinY = ct < zt ? ct - padding : zt;
+    const newMaxX = cr > zr ? cr + padding : zr;
+    const newMaxY = cb > zb ? cb + padding : zb;
+    if (newMinX === zl && newMinY === zt && newMaxX === zr && newMaxY === zb) {
+        return null;
+    }
+    return {
+        x: newMinX,
+        y: newMinY,
+        width: newMaxX - newMinX,
+        height: newMaxY - newMinY,
+    };
+};
+/**
+ * Required shape-level `width` / `height` (when present) that match
+ * the new local drop-zone. Used by the editor after `expandDropZoneToFit`
+ * to sync the container's visual with the expanded zone.
+ * Preserves the existing dropZone offset within the shape — if the
+ * dropZone didn't start at (0,0), the shape grows by exactly the amount
+ * added to the dropZone, without shifting the offset.
+ */
+export const containerSizeForZone = (current, nextZone) => {
+    const z = current.spec.dropZone;
+    // The amount added on the left/top shifts the container's position,
+    // and the dropZone moves back by the same amount so the shape-to-zone
+    // offset stays the same.
+    const dxLeft = z.x - nextZone.x;
+    const dyTop = z.y - nextZone.y;
+    const dxRight = nextZone.x + nextZone.width - (z.x + z.width);
+    const dyBottom = nextZone.y + nextZone.height - (z.y + z.height);
+    return {
+        width: current.width + dxLeft + dxRight,
+        height: current.height + dyTop + dyBottom,
+        positionOffset: { x: -dxLeft, y: -dyTop },
+    };
+};
+//# sourceMappingURL=container.js.map

package/dist/container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.js","sourceRoot":"","sources":["../src/container.ts"],"names":[],"mappings":"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"}

package/dist/diff.d.ts

@@ -0,0 +1,22 @@
+import type { ElementId } from "@oh-just-another/types";
+import type { Scene } from "./scene.js";
+/**
+ * Element-level diff between two scenes. Categorises every shape id
+ * present in either scene as:
+ *
+ * - `added`: in `next` only.
+ * - `removed`: in `prev` only.
+ * - `modified`: in both, but the shape reference differs (immutable
+ *   patches replace the object).
+ *
+ * Reference equality is sufficient — scene mutations always go
+ * through `apply(scene, patch)` which produces fresh shape objects
+ * for every change. Pure read paths don't allocate.
+ */
+export interface SceneElementDiff {
+    readonly added: readonly ElementId[];
+    readonly removed: readonly ElementId[];
+    readonly modified: readonly ElementId[];
+}
+export declare const diffSceneElements: (prev: Scene, next: Scene) => SceneElementDiff;
+//# sourceMappingURL=diff.d.ts.map

package/dist/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAC;CACzC;AAED,eAAO,MAAM,iBAAiB,GAAI,MAAM,KAAK,EAAE,MAAM,KAAK,KAAG,gBAa5D,CAAC"}

package/dist/diff.js

@@ -0,0 +1,18 @@
+export const diffSceneElements = (prev, next) => {
+    const added = [];
+    const removed = [];
+    const modified = [];
+    for (const [id, shape] of next.elements) {
+        const before = prev.elements.get(id);
+        if (before === undefined)
+            added.push(id);
+        else if (before !== shape)
+            modified.push(id);
+    }
+    for (const id of prev.elements.keys()) {
+        if (!next.elements.has(id))
+            removed.push(id);
+    }
+    return { added, removed, modified };
+};
+//# sourceMappingURL=diff.js.map

package/dist/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAsBA,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAAW,EAAE,IAAW,EAAoB,EAAE;IAC9E,MAAM,KAAK,GAAgB,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAgB,EAAE,CAAC;IAChC,MAAM,QAAQ,GAAgB,EAAE,CAAC;IACjC,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QACxC,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACrC,IAAI,MAAM,KAAK,SAAS;YAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;aACpC,IAAI,MAAM,KAAK,KAAK;YAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC/C,CAAC;IACD,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;QACtC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;AACtC,CAAC,CAAC"}

package/dist/edge-curve.d.ts

@@ -0,0 +1,37 @@
+import type { Vec2 } from "@oh-just-another/types";
+/**
+ * Curved (bezier) link geometry — the single source of truth for the curve
+ * shape so the renderer (draws cubic beziers) and hit-testing / bounds
+ * (flatten the same curve) never disagree. A curved link bows away from the
+ * straight polyline; testing clicks against the polyline would miss the
+ * visible arc, so callers flatten the curve here instead.
+ */
+/** One cubic bezier segment: control points + end (start is implicit/prev). */
+export interface BezierSegment {
+    readonly c1: Vec2;
+    readonly c2: Vec2;
+    readonly to: Vec2;
+}
+/**
+ * Cubic bezier from `from` to `to` that LEAVES `from` along `dirFrom` and
+ * ENTERS `to` along `-dirTo` (both unit outward directions). This makes a
+ * connector exit/enter perpendicular to an element's edge (flowchart look),
+ * instead of always bowing to one fixed side. Control-arm length scales with
+ * the endpoint distance (capped).
+ */
+export declare const cubicWithEndTangents: (from: Vec2, to: Vec2, dirFrom: Vec2, dirTo: Vec2) => BezierSegment;
+/**
+ * Catmull-Rom spline through `pts` as cubic bezier segments. Each segment
+ * Pi→Pi+1 uses tangents from the neighbouring points; endpoints duplicate
+ * themselves. The curve passes through every point with no corners. Used for
+ * a waypointed curve (the bends define the shape).
+ */
+export declare const catmullRomBeziers: (pts: readonly Vec2[]) => BezierSegment[];
+/** Point on a cubic bezier at parameter `t` (0..1). de Casteljau / Bernstein. */
+export declare const cubicAt: (p0: Vec2, c1: Vec2, c2: Vec2, p1: Vec2, t: number) => Vec2;
+/**
+ * Flatten a `start` + cubic-segment list into a dense point list (for
+ * hit-testing / bounds). Includes `start` then `perSegment` samples per cubic.
+ */
+export declare const flattenSegments: (start: Vec2, segments: readonly BezierSegment[], perSegment?: number) => Vec2[];
+//# sourceMappingURL=edge-curve.d.ts.map

package/dist/edge-curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-curve.d.ts","sourceRoot":"","sources":["../src/edge-curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAanD;;;;;;GAMG;AAEH,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;CACnB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAM,IAAI,EACV,IAAI,IAAI,EACR,SAAS,IAAI,EACb,OAAO,IAAI,KACV,aAQF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,KAAK,SAAS,IAAI,EAAE,KAAG,aAAa,EAerE,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,OAAO,GAAI,IAAI,IAAI,EAAE,IAAI,IAAI,EAAE,IAAI,IAAI,EAAE,IAAI,IAAI,EAAE,GAAG,MAAM,KAAG,IAU3E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,IAAI,EACX,UAAU,SAAS,aAAa,EAAE,EAClC,mBAAmC,KAClC,IAAI,EAUN,CAAC"}