@react-shimeji/core 0.2.3 → 0.3.1

package/dist/index.cjs

@@ -47,68 +47,83 @@ module.exports = __toCommonJS(index_exports);
 
 // src/dom.ts
 var DomManager = class {
-  /** Uses the supplied element only as a mount point for independent mascots. */
+  /** Uses the supplied element as the containing block and clipping boundary. */
   constructor(container, sprites) {
     this.container = container;
     this.sprites = sprites;
+    const view = container.ownerDocument.defaultView;
+    const computedStyle = view?.getComputedStyle(container);
+    if (!computedStyle?.position || computedStyle.position === "static") this.applyContainerStyle("position", "relative");
+    if (computedStyle?.overflowX === "visible" || !computedStyle?.overflowX) {
+      this.applyContainerStyle("overflowX", "clip");
+    }
   }
   container;
   sprites;
   handles = /* @__PURE__ */ new Set();
+  restoreContainerStyles = [];
   /** Reattaches mascot elements if application code temporarily removed them. */
   ensureMounted() {
-    const target = this.container.ownerDocument.body;
     for (const handle of this.handles) {
-      if (handle.element.parentElement !== target) target.appendChild(handle.element);
+      if (handle.element.parentElement !== this.container) this.container.appendChild(handle.element);
     }
   }
-  /** Returns viewport bounds because fixed mascots use viewport coordinates. */
+  /** Returns bounds in the container-local coordinate system. */
   getBounds() {
-    const view = this.container.ownerDocument.defaultView ?? window;
-    return { x: 0, y: 0, width: view.innerWidth, height: view.innerHeight };
+    return { x: 0, y: 0, width: this.container.clientWidth, height: this.container.clientHeight };
+  }
+  /** Converts a viewport client coordinate into container-local coordinates. */
+  toLocalPoint(clientX, clientY) {
+    const rectangle = this.container.getBoundingClientRect();
+    return { x: clientX - rectangle.left, y: clientY - rectangle.top };
   }
   /** Creates a mascot node and acquires its spritesheet resource. */
   createMascot(spec, mascotId, mascotClassName) {
     const spriteLease = this.sprites.acquire(spec.spritesheet);
-    const element = document.createElement("div");
+    const element = this.container.ownerDocument.createElement("div");
     element.dataset.shimejiId = mascotId;
+    element.setAttribute("aria-hidden", "true");
     if (mascotClassName) element.className = mascotClassName;
-    Object.assign(element.style, { position: "fixed", left: "0", top: "0", width: "0", height: "0", pointerEvents: "none", zIndex: "9999", userSelect: "none", willChange: "transform" });
-    const spriteElement = document.createElement("div");
+    Object.assign(element.style, { position: "absolute", left: "0", top: "0", width: "0", height: "0", pointerEvents: "none", zIndex: "9999", userSelect: "none", willChange: "transform" });
+    const spriteElement = this.container.ownerDocument.createElement("div");
     Object.assign(spriteElement.style, { position: "absolute", left: "0", top: "0", backgroundRepeat: "no-repeat", transformOrigin: "center center", pointerEvents: "auto", touchAction: "none", userSelect: "none" });
     element.appendChild(spriteElement);
     const handle = { element, spriteElement, spriteLease };
     this.handles.add(handle);
-    this.container.ownerDocument.body.appendChild(element);
+    this.container.appendChild(element);
     return handle;
   }
   /** Paints one mascot state into its existing DOM nodes. */
   render(handle, spec, state) {
     const sprite = this.sprites.resolve(spec, handle.spriteLease, state.sprite);
-    handle.element.style.transform = `translate3d(${state.x - state.anchorX}px, ${state.y - state.anchorY}px, 0)`;
     handle.spriteElement.style.left = "0";
     handle.spriteElement.style.top = "0";
     handle.spriteElement.style.transform = `scaleX(${state.lookRight ? -1 : 1})`;
-    if (!sprite) return;
+    if (!sprite) {
+      handle.element.style.transform = `translate3d(${state.x - state.anchorX}px, ${state.y - state.anchorY}px, 0)`;
+      return;
+    }
+    let width = 128;
+    let height = 128;
     handle.spriteElement.style.backgroundImage = `url("${sprite.url.replaceAll('"', '\\"')}")`;
     if (sprite.rectangle) {
-      handle.spriteElement.style.width = `${sprite.rectangle.width}px`;
-      handle.spriteElement.style.height = `${sprite.rectangle.height}px`;
-      handle.element.style.width = `${sprite.rectangle.width}px`;
-      handle.element.style.height = `${sprite.rectangle.height}px`;
+      width = sprite.rectangle.width;
+      height = sprite.rectangle.height;
       handle.spriteElement.style.backgroundPosition = `${-sprite.rectangle.x}px ${-sprite.rectangle.y}px`;
       handle.spriteElement.style.backgroundSize = "auto";
     } else {
       handle.spriteElement.style.backgroundPosition = "0 0";
       handle.spriteElement.style.backgroundSize = "contain";
-      handle.spriteElement.style.width = "128px";
-      handle.spriteElement.style.height = "128px";
       const definition = Object.values(spec.sprites).find((candidate) => typeof candidate === "object" && "url" in candidate && candidate.url === sprite.url);
-      if (typeof definition === "object" && "width" in definition && definition.width !== void 0) handle.spriteElement.style.width = `${definition.width}px`;
-      if (typeof definition === "object" && "height" in definition && definition.height !== void 0) handle.spriteElement.style.height = `${definition.height}px`;
-      handle.element.style.width = handle.spriteElement.style.width;
-      handle.element.style.height = handle.spriteElement.style.height;
+      if (typeof definition === "object" && "width" in definition && definition.width !== void 0) width = definition.width;
+      if (typeof definition === "object" && "height" in definition && definition.height !== void 0) height = definition.height;
     }
+    handle.spriteElement.style.width = `${width}px`;
+    handle.spriteElement.style.height = `${height}px`;
+    handle.element.style.width = `${width}px`;
+    handle.element.style.height = `${height}px`;
+    const anchorX = state.lookRight ? width - state.anchorX : state.anchorX;
+    handle.element.style.transform = `translate3d(${state.x - anchorX}px, ${state.y - state.anchorY}px, 0)`;
   }
   /** Removes one mascot node and releases its temporary image URL. */
   removeMascot(handle) {
@@ -124,6 +139,14 @@ var DomManager = class {
   /** Removes every mascot element and releases its temporary image URL. */
   destroy() {
     for (const handle of [...this.handles]) this.removeMascot(handle);
+    for (const restore of this.restoreContainerStyles.splice(0).reverse()) restore();
+  }
+  applyContainerStyle(property, value) {
+    const previous = this.container.style[property];
+    this.container.style[property] = value;
+    this.restoreContainerStyles.push(() => {
+      if (this.container.style[property] === value) this.container.style[property] = previous;
+    });
   }
 };
 
@@ -136,6 +159,9 @@ var actionTypeNames = {
   Animate: "Animate",
   Move: "Move",
   Embedded: "Embedded",
+  Composite: "Sequence",
+  Fixed: "Animate",
+  Pause: "Stay",
   \u8907\u5408: "Sequence",
   \u9078\u629E: "Select",
   \u53C2\u7167: "Reference",
@@ -185,12 +211,13 @@ function actionProperty(element, ...names) {
 function parseAnimation(element) {
   const poses = directChildren(element, "Pose", "\u30DD\u30FC\u30BA").map((pose) => ({
     sprite: attribute(pose, "Image", "\u753B\u50CF") ?? "/shime1.png",
-    anchor: parsePoint(attribute(pose, "Anchor", "\u57FA\u6E96\u5EA7\u6A19"), { x: 64, y: 128 }),
+    anchor: parsePoint(attribute(pose, "ImageAnchor", "Anchor", "\u57FA\u6E96\u5EA7\u6A19"), { x: 64, y: 128 }),
     velocity: parsePoint(attribute(pose, "Velocity", "\u79FB\u52D5\u901F\u5EA6")),
     duration: Number(attribute(pose, "Duration", "\u9577\u3055") ?? 1)
   }));
   const condition = attribute(element, "Condition", "\u6761\u4EF6");
-  return { poses, ...condition !== void 0 && { condition } };
+  const turn = (attribute(element, "IsTurn", "Turn") ?? "false").toLowerCase() === "true";
+  return { poses, ...condition !== void 0 && { condition }, ...turn && { turn } };
 }
 function parseActionElement(element) {
   const isReference = element.localName === "ActionReference" || element.localName === "\u52D5\u4F5C\u53C2\u7167";
@@ -214,20 +241,26 @@ function parseActionElement(element) {
   };
   const properties = [
     ["duration", actionProperty(element, "Duration", "\u9577\u3055")],
-    ["gap", actionProperty(element, "Gap", "\u9593\u9694")],
+    ["gap", actionProperty(element, "Gap", "\u9593\u9694", "\u305A\u308C")],
     ["targetX", actionProperty(element, "TargetX", "\u76EE\u7684\u5730X")],
     ["targetY", actionProperty(element, "TargetY", "\u76EE\u7684\u5730Y")],
-    ["velocity", actionProperty(element, "Velocity", "\u901F\u5EA6")],
+    ["velocity", actionProperty(element, "VelocityParam", "Velocity", "\u901F\u5EA6")],
     ["x", actionProperty(element, "X", "\u5909\u4F4DX")],
     ["y", actionProperty(element, "Y", "\u5909\u4F4DY")],
+    ["offsetX", actionProperty(element, "OffsetX", "\u7AEFX")],
+    ["offsetY", actionProperty(element, "OffsetY", "\u7AEFY")],
+    ["offsetType", actionProperty(element, "OffsetType")],
     ["initialVx", actionProperty(element, "InitialVX", "InitialVx", "\u521D\u901FX")],
     ["initialVy", actionProperty(element, "InitialVY", "InitialVy", "\u521D\u901FY")],
-    ["resistanceX", actionProperty(element, "ResistanceX", "\u7A7A\u6C17\u62B5\u6297X")],
-    ["resistanceY", actionProperty(element, "ResistanceY", "\u7A7A\u6C17\u62B5\u6297Y")],
+    ["resistanceX", actionProperty(element, "RegistanceX", "ResistanceX", "\u7A7A\u6C17\u62B5\u6297X")],
+    ["resistanceY", actionProperty(element, "RegistanceY", "ResistanceY", "\u7A7A\u6C17\u62B5\u6297Y")],
     ["gravity", actionProperty(element, "Gravity", "\u91CD\u529B")],
-    ["bornX", actionProperty(element, "BornX", "\u8A95\u751FX")],
-    ["bornY", actionProperty(element, "BornY", "\u8A95\u751FY")],
-    ["bornBehavior", actionProperty(element, "BornBehavior", "\u8A95\u751F\u6642\u306E\u884C\u52D5")],
+    ["bornX", actionProperty(element, "BornX", "\u8A95\u751FX", "\u751F\u307E\u308C\u308B\u5834\u6240X")],
+    ["bornY", actionProperty(element, "BornY", "\u8A95\u751FY", "\u751F\u307E\u308C\u308B\u5834\u6240Y")],
+    ["bornBehavior", actionProperty(element, "BornBehavior", "BornBehaviour", "\u8A95\u751F\u6642\u306E\u884C\u52D5", "\u751F\u307E\u308C\u305F\u6642\u306E\u884C\u52D5")],
+    ["bornMascot", actionProperty(element, "BornMascot")],
+    ["bornCount", actionProperty(element, "BornCount")],
+    ["bornInterval", actionProperty(element, "BornInterval")],
     ["ieOffsetX", actionProperty(element, "IEOffsetX", "IE\u306E\u7AEFX")],
     ["ieOffsetY", actionProperty(element, "IEOffsetY", "IE\u306E\u7AEFY")],
     ["lookRight", actionProperty(element, "LookRight", "\u53F3\u5411\u304D")]
@@ -243,18 +276,33 @@ function parseActionsXml(xml) {
   const roots = lists.length ? lists : [document2.documentElement];
   return roots.flatMap((list) => directChildren(list, "Action", "\u52D5\u4F5C").map(parseActionElement));
 }
+function parseNextBehaviors(element, inheritedConditions) {
+  const behaviors = [];
+  for (const child of Array.from(element.children)) {
+    if (child.localName === "Condition" || child.localName === "\u6761\u4EF6") {
+      const condition = attribute(child, "Condition", "\u6761\u4EF6");
+      behaviors.push(...parseNextBehaviors(child, [...inheritedConditions, ...condition ? [condition] : []]));
+    } else if (["Behavior", "\u884C\u52D5", "BehaviorReference", "BehaviorReferance", "\u884C\u52D5\u53C2\u7167"].includes(child.localName)) {
+      behaviors.push(parseBehaviorElement(child, inheritedConditions, 0));
+    }
+  }
+  return behaviors;
+}
 function parseBehaviorElement(element, inheritedConditions, groupIndex) {
   const condition = attribute(element, "Condition", "\u6761\u4EF6");
   const conditions = [...inheritedConditions, ...condition ? [condition] : []];
   const nextList = directChildren(element, "NextBehaviorList", "NextBehavior", "\u6B21\u306E\u884C\u52D5\u30EA\u30B9\u30C8")[0];
-  const nextBehaviors = nextList ? directChildren(nextList, "Behavior", "\u884C\u52D5", "BehaviorReference", "BehaviorReferance", "\u884C\u52D5\u53C2\u7167").map((child) => parseBehaviorElement(child, conditions, 0)) : [];
+  const nextBehaviors = nextList ? parseNextBehaviors(nextList, []) : [];
   const reference = element.localName === "BehaviorReference" || element.localName === "BehaviorReferance" || element.localName === "\u884C\u52D5\u53C2\u7167";
+  const actionName = attribute(element, "Action", "\u52D5\u4F5C");
   return {
     type: reference ? "Reference" : "Behavior",
     name: attribute(element, "Name", "\u540D\u524D") ?? "",
     frequency: Number(attribute(element, "Frequency", "\u983B\u5EA6") ?? 0),
     conditions,
     nextBehaviors,
+    ...nextList && { nextAdditive: (attribute(nextList, "Add", "\u8FFD\u52A0") ?? "true").toLowerCase() === "true" },
+    ...actionName !== void 0 && { actionName },
     groupIndex,
     hidden: (attribute(element, "Hidden", "\u975E\u8868\u793A") ?? "false").toLowerCase() === "true"
   };
@@ -360,7 +408,7 @@ var functions = {
 };
 var constants = { E: Math.E, PI: Math.PI };
 function normalizeExpression(source) {
-  return source.trim().replace(/^(?:#|\$)\{/, "").replace(/\}$/, "").replace(/Math\.(random|min|max|abs|floor|ceil|round|sqrt|pow|sin|cos|tan|asin|acos|atan|sinh|cosh|tanh|asinh|acosh|atanh|cbrt|log|log2|log10|exp|expm1|log1p|trunc|sign|hypot|atan2)/g, "$1").replace(/Math\.(PI|E)\b/g, "$1").replace(/Mascot\./gi, "mascot.").replace(/TargetX|目的地X/gi, "targetX").replace(/TargetY|目的地Y/gi, "targetY").replace(/FootX|足X/gi, "footX").replace(/FootY|足Y/gi, "footY").replace(/MaxCount/gi, "maxCount").replace(/Gap/gi, "gap").replace(/\band\b/gi, "&&").replace(/\bor\b/gi, "||").replace(/\bnot\b/gi, "!");
+  return source.trim().replace(/^(?:#|\$)\{/, "").replace(/\}$/, "").replace(/Math\.(random|min|max|abs|floor|ceil|round|sqrt|pow|sin|cos|tan|asin|acos|atan|sinh|cosh|tanh|asinh|acosh|atanh|cbrt|log|log2|log10|exp|expm1|log1p|trunc|sign|hypot|atan2)/g, "$1").replace(/Math\.(PI|E)\b/g, "$1").replace(/Mascot\./gi, "mascot.").replace(/TargetX|目的地X/gi, "targetX").replace(/TargetY|目的地Y/gi, "targetY").replace(/FootX|足X/gi, "footX").replace(/FootY|足Y/gi, "footY").replace(/VelocityX|速度X/gi, "velocityX").replace(/VelocityY|速度Y/gi, "velocityY").replace(/MaxCount/gi, "maxCount").replace(/Gap|ずれ/gi, "gap").replace(/\band\b/gi, "&&").replace(/\bor\b/gi, "||").replace(/\bnot\b/gi, "!");
 }
 function tokenize(source) {
   const tokens = [];
@@ -561,7 +609,7 @@ function evaluateNode(node, scope) {
   }
 }
 var expressionCache = /* @__PURE__ */ new Map();
-function evaluateExpression(expression, environment, fallback) {
+function evaluateExpression(expression, environment, fallback, random = Math.random) {
   if (expression === void 0) return fallback;
   if (typeof expression !== "string") return expression;
   try {
@@ -571,7 +619,7 @@ function evaluateExpression(expression, environment, fallback) {
       ast = new Parser(tokenize(normalized)).parse();
       expressionCache.set(normalized, ast);
     }
-    const result = evaluateNode(ast, environment);
+    const result = evaluateNode(ast, { ...environment, random: (maximum = 1) => random() * Number(maximum) });
     if (typeof fallback === "boolean") return Boolean(result);
     const numericResult = Number(result);
     return Number.isNaN(numericResult) ? fallback : numericResult;
@@ -579,8 +627,8 @@ function evaluateExpression(expression, environment, fallback) {
     return fallback;
   }
 }
-function conditionsMatch(conditions, environment) {
-  return conditions.every((condition) => evaluateExpression(condition, environment, false));
+function conditionsMatch(conditions, environment, random = Math.random) {
+  return conditions.every((condition) => evaluateExpression(condition, environment, false, random));
 }
 function selectWeighted(items, weight, random = Math.random) {
   const weighted = items.map((item) => ({ item, weight: Math.max(0, weight(item)) }));
@@ -602,62 +650,76 @@ var BehaviorController = class {
   spec;
   random;
   previous;
+  fallbackSelected = false;
   /** Selects an initial behavior, honoring an explicit requested name when possible. */
   selectInitial(environment, requestedName) {
+    this.fallbackSelected = false;
     if (requestedName) {
       const requested = this.spec.behaviors.find((behavior) => behavior.name === requestedName);
-      if (requested && conditionsMatch(requested.conditions, environment)) return this.previous = this.resolve(requested);
+      if (requested) return this.previous = this.resolve(requested);
     }
-    const fall = this.findFallBehavior();
-    if (fall && !this.isOnAnyBoundary(environment)) return this.previous = fall;
     return this.previous = this.choose(this.spec.behaviors, environment);
   }
   /** Selects the weighted transition following the current behavior. */
   selectNext(environment) {
-    const pool = this.previous?.nextBehaviors.length ? this.previous.nextBehaviors : this.spec.behaviors;
-    return this.previous = this.choose(pool, environment) ?? this.findFallBehavior();
+    const next = this.previous?.nextBehaviors ?? [];
+    const pool = this.previous && this.previous.nextAdditive === false ? next : [...this.spec.behaviors, ...next];
+    const selected = this.choose(pool, environment);
+    this.fallbackSelected = selected === void 0;
+    return this.previous = selected ?? this.findFallBehavior();
+  }
+  /** Whether the most recent transition had no effective weighted candidate. */
+  usedFallback() {
+    return this.fallbackSelected;
   }
   /** Replaces selection history so an external interaction can force a behavior. */
   force(name) {
+    this.fallbackSelected = false;
     const behavior = this.spec.behaviors.find((candidate) => candidate.name === name);
     return this.previous = behavior ? this.resolve(behavior) : void 0;
   }
   choose(pool, environment) {
-    const applicable = pool.filter((behavior) => conditionsMatch(behavior.conditions, environment));
+    const applicable = pool.filter((behavior) => conditionsMatch(behavior.conditions, environment, this.random));
     const chosen = selectWeighted(applicable, (behavior) => behavior.frequency, this.random);
     return chosen ? this.resolve(chosen) : void 0;
   }
   resolve(behavior) {
     if (behavior.type !== "Reference") return behavior;
     const target = this.spec.behaviors.find((candidate) => candidate.type === "Behavior" && candidate.name === behavior.name);
-    return target ? { ...target, ...behavior, type: "Behavior", nextBehaviors: target.nextBehaviors } : { ...behavior, type: "Behavior" };
+    return target ? {
+      ...target,
+      ...behavior,
+      type: "Behavior",
+      nextBehaviors: target.nextBehaviors,
+      ...behavior.actionName !== void 0 ? { actionName: behavior.actionName } : target.actionName !== void 0 ? { actionName: target.actionName } : {},
+      ...target.nextAdditive !== void 0 && { nextAdditive: target.nextAdditive }
+    } : { ...behavior, type: "Behavior" };
   }
   findFallBehavior() {
     return this.spec.behaviors.find((behavior) => behavior.name === "Fall" || behavior.name === "\u843D\u4E0B\u3059\u308B");
   }
-  isOnAnyBoundary(environment) {
-    const anchor = environment.mascot.anchor;
-    const area = environment.mascot.environment.workArea;
-    const activeIE = environment.mascot.environment.activeIE;
-    return area.topBorder.isOn(anchor) || area.leftBorder.isOn(anchor) || area.rightBorder.isOn(anchor) || area.bottomBorder.isOn(anchor) || activeIE.visible && (activeIE.topBorder.isOn(anchor) || activeIE.leftBorder.isOn(anchor) || activeIE.rightBorder.isOn(anchor) || activeIE.bottomBorder.isOn(anchor));
-  }
 };
 
 // src/physics.ts
+var BORDER_TOLERANCE = 1 - Number.EPSILON / 2;
+function isWithinSpan(value, minimum, maximum, tolerance) {
+  const distance = value < minimum ? minimum - value : value > maximum ? value - maximum : 0;
+  return distance <= tolerance;
+}
 function clamp(value, minimum, maximum) {
   return Math.min(Math.max(value, minimum), maximum);
 }
-function isOnTop(point, rectangle, tolerance = 1) {
-  return point.x >= rectangle.x - tolerance && point.x <= rectangle.x + rectangle.width + tolerance && Math.abs(point.y - rectangle.y) <= tolerance;
+function isOnTop(point, rectangle, tolerance = BORDER_TOLERANCE) {
+  return isWithinSpan(point.x, rectangle.x, rectangle.x + rectangle.width, tolerance) && Math.abs(point.y - rectangle.y) <= tolerance;
 }
-function isOnBottom(point, rectangle, tolerance = 1) {
-  return point.x >= rectangle.x - tolerance && point.x <= rectangle.x + rectangle.width + tolerance && Math.abs(point.y - rectangle.y - rectangle.height) <= tolerance;
+function isOnBottom(point, rectangle, tolerance = BORDER_TOLERANCE) {
+  return isWithinSpan(point.x, rectangle.x, rectangle.x + rectangle.width, tolerance) && Math.abs(point.y - rectangle.y - rectangle.height) <= tolerance;
 }
-function isOnLeft(point, rectangle, tolerance = 1) {
-  return point.y >= rectangle.y - tolerance && point.y <= rectangle.y + rectangle.height + tolerance && Math.abs(point.x - rectangle.x) <= tolerance;
+function isOnLeft(point, rectangle, tolerance = BORDER_TOLERANCE) {
+  return isWithinSpan(point.y, rectangle.y, rectangle.y + rectangle.height, tolerance) && Math.abs(point.x - rectangle.x) <= tolerance;
 }
-function isOnRight(point, rectangle, tolerance = 1) {
-  return point.y >= rectangle.y - tolerance && point.y <= rectangle.y + rectangle.height + tolerance && Math.abs(point.x - rectangle.x - rectangle.width) <= tolerance;
+function isOnRight(point, rectangle, tolerance = BORDER_TOLERANCE) {
+  return isWithinSpan(point.y, rectangle.y, rectangle.y + rectangle.height, tolerance) && Math.abs(point.x - rectangle.x - rectangle.width) <= tolerance;
 }
 function isOnBorder(state, bounds, border, platform) {
   if (!border) return true;
@@ -665,29 +727,46 @@ function isOnBorder(state, bounds, border, platform) {
   if (border === "Ceiling") return isOnTop(state, bounds) || platform !== void 0 && isOnBottom(state, platform);
   return isOnLeft(state, bounds) || isOnRight(state, bounds) || platform !== void 0 && (isOnLeft(state, platform) || isOnRight(state, platform));
 }
-function applyGravity(state, bounds, frameScale, gravity, resistanceX = 0.05, resistanceY = 0.01, platform) {
-  const previousY = state.y;
-  const nextX = clamp(state.x + state.vx * frameScale, bounds.x, bounds.x + bounds.width);
-  const nextY = clamp(state.y + state.vy * frameScale, bounds.y, bounds.y + bounds.height);
-  state.x = nextX;
-  state.y = nextY;
-  state.vx *= Math.max(0, 1 - resistanceX * frameScale);
-  state.vy = state.vy * Math.max(0, 1 - resistanceY * frameScale) + gravity * frameScale;
-  if (platform && nextY >= previousY && previousY <= platform.y && nextY >= platform.y && nextX >= platform.x && nextX <= platform.x + platform.width) {
-    state.y = platform.y;
-    state.vy = 0;
-    return true;
-  }
-  if (state.y >= bounds.y + bounds.height) {
-    state.y = bounds.y + bounds.height;
-    state.vy = 0;
-    return true;
-  }
-  if (state.x <= bounds.x || state.x >= bounds.x + bounds.width) {
-    state.vx = 0;
-    return true;
+function isOnFloor(point, bounds, platforms = []) {
+  return platforms.some((platform) => isOnTop(point, platform)) || isOnBottom(point, bounds);
+}
+function isOnWall(point, bounds, lookRight, platforms = []) {
+  return lookRight ? platforms.some((platform) => isOnLeft(point, platform)) || isOnRight(point, bounds) : platforms.some((platform) => isOnRight(point, platform)) || isOnLeft(point, bounds);
+}
+function applyGravity(state, bounds, frameScale, gravity, resistanceX = 0.05, resistanceY = 0.1, platform) {
+  const platforms = platform ? [platform] : [];
+  const steps = Math.max(1, Math.round(frameScale));
+  let stopped = false;
+  for (let frame = 0; frame < steps && !stopped; frame += 1) {
+    state.vx -= state.vx * resistanceX;
+    state.vy = state.vy - state.vy * resistanceY + gravity;
+    const dx = Math.trunc(state.vx);
+    const dy = Math.trunc(state.vy);
+    const divisions = Math.max(1, Math.abs(dx), Math.abs(dy));
+    const start = { x: state.x, y: state.y };
+    for (let index = 0; index <= divisions; index += 1) {
+      const x = start.x + Math.trunc(dx * index / divisions);
+      const y = start.y + Math.trunc(dy * index / divisions);
+      state.x = x;
+      state.y = y;
+      if (dy > 0) {
+        for (let offset = -80; offset <= 0; offset += 1) {
+          state.y = y + offset;
+          if (isOnFloor(state, bounds, platforms)) {
+            stopped = true;
+            break;
+          }
+        }
+        if (stopped) break;
+        state.y = y;
+      }
+      if (isOnWall(state, bounds, state.lookRight, platforms)) {
+        stopped = true;
+        break;
+      }
+    }
   }
-  return false;
+  return stopped;
 }
 function moveToward(state, target, speed, frameScale) {
   const dx = target.x - state.x;
@@ -704,251 +783,832 @@ function moveToward(state, target, speed, frameScale) {
 }
 
 // src/action.ts
-function numeric(value, environment) {
-  return value === void 0 ? void 0 : evaluateExpression(value, environment, 0);
+function expressionIsPerFrame(value) {
+  return typeof value === "string" && value.trimStart().startsWith("#{");
 }
-function evaluateAction(definition, environment) {
-  const gap = numeric(definition.gap, environment) ?? 0;
-  const scopedEnvironment = { ...environment, gap };
-  const targetX = numeric(definition.targetX, scopedEnvironment);
-  const initialVx = numeric(definition.initialVx, scopedEnvironment);
-  let lookRight = environment.mascot.lookRight;
-  if (definition.borderType === "Wall") {
-    const { activeIE, workArea } = environment.mascot.environment;
-    lookRight = workArea.rightBorder.isOn(environment.mascot.anchor) || activeIE.visible && activeIE.leftBorder.isOn(environment.mascot.anchor);
-  } else if (definition.type === "Move" || definition.embedType === "Jump" || definition.embedType === "WalkWithIE") {
-    if (targetX !== void 0) lookRight = targetX > environment.mascot.anchor.x;
-  } else if (definition.embedType === "Fall" || definition.embedType === "FallWithIE") {
-    if (initialVx !== void 0 && initialVx !== 0) lookRight = initialVx > 0;
-  } else if (definition.embedType === "Look") {
-    lookRight = definition.lookRight === void 0 ? !environment.mascot.lookRight : typeof definition.lookRight === "boolean" ? definition.lookRight : evaluateExpression(definition.lookRight, scopedEnvironment, environment.mascot.lookRight);
-  }
-  const duration = numeric(definition.duration, scopedEnvironment);
-  const targetY = numeric(definition.targetY, scopedEnvironment);
-  const velocity = numeric(definition.velocity, scopedEnvironment);
-  const x = numeric(definition.x, scopedEnvironment);
-  const y = numeric(definition.y, scopedEnvironment);
-  const initialVy = numeric(definition.initialVy, scopedEnvironment);
-  const resistanceX = numeric(definition.resistanceX, scopedEnvironment);
-  const resistanceY = numeric(definition.resistanceY, scopedEnvironment);
-  const gravity = numeric(definition.gravity, scopedEnvironment);
-  const bornX = numeric(definition.bornX, scopedEnvironment);
-  const bornY = numeric(definition.bornY, scopedEnvironment);
-  return {
-    definition,
-    lookRight,
-    ...duration !== void 0 && { duration },
-    ...targetX !== void 0 && { targetX },
-    ...targetY !== void 0 && { targetY },
-    ...velocity !== void 0 && { velocity },
-    ...x !== void 0 && { x },
-    ...y !== void 0 && { y },
-    ...initialVx !== void 0 && { initialVx },
-    ...initialVy !== void 0 && { initialVy },
-    ...resistanceX !== void 0 && { resistanceX },
-    ...resistanceY !== void 0 && { resistanceY },
-    ...gravity !== void 0 && { gravity },
-    ...bornX !== void 0 && { bornX },
-    ...bornY !== void 0 && { bornY }
-  };
+var ActionValues = class {
+  constructor(random) {
+    this.random = random;
+  }
+  random;
+  actionCache = /* @__PURE__ */ new Map();
+  frameCache = /* @__PURE__ */ new Map();
+  init() {
+    this.actionCache.clear();
+    this.frameCache.clear();
+  }
+  initFrame() {
+    this.frameCache.clear();
+  }
+  number(key, value, environment, fallback) {
+    if (value === void 0) return fallback;
+    if (typeof value === "number") return value;
+    const cache = expressionIsPerFrame(value) ? this.frameCache : this.actionCache;
+    const cached = cache.get(key);
+    if (typeof cached === "number") return cached;
+    const result = evaluateExpression(value, environment, fallback, this.random);
+    cache.set(key, result);
+    return result;
+  }
+  boolean(key, value, environment, fallback) {
+    if (value === void 0) return fallback;
+    if (typeof value === "boolean") return value;
+    const cache = expressionIsPerFrame(value) ? this.frameCache : this.actionCache;
+    const cached = cache.get(key);
+    if (typeof cached === "boolean") return cached;
+    const result = evaluateExpression(value, environment, fallback, this.random);
+    cache.set(key, result);
+    return result;
+  }
+};
+var RuntimeBase = class {
+  constructor(definition, random) {
+    this.definition = definition;
+    this.values = new ActionValues(random);
+  }
+  definition;
+  time = 0;
+  values;
+  init(context) {
+    this.time = 0;
+    this.values.init();
+    this.onInit(context);
+  }
+  hasNext(context) {
+    return this.baseHasNext(context) && this.hasMore(context);
+  }
+  step(context) {
+    this.values.initFrame();
+    const result = this.tick(context);
+    this.time += 1;
+    return result;
+  }
+  onInit(_context) {
+  }
+  hasMore(_context) {
+    return true;
+  }
+  baseHasNext(context) {
+    const condition = this.values.boolean("condition", this.definition.condition, context.environment, true);
+    const duration = Math.trunc(this.values.number("duration", this.definition.duration, context.environment, Number.POSITIVE_INFINITY));
+    return condition && this.time < duration;
+  }
+};
+var TrackedBorder = class {
+  constructor(side, source, context) {
+    this.side = side;
+    this.source = source;
+    this.previous = this.rectangle(context);
+  }
+  side;
+  source;
+  previous;
+  move(point, context) {
+    const current = this.rectangle(context);
+    const previous = this.previous;
+    this.previous = current;
+    if (!current || !previous) return point;
+    if (this.side === "left" || this.side === "right") {
+      if (previous.height === 0) return point;
+      const next2 = {
+        x: point.x + this.coordinate(current) - this.coordinate(previous),
+        y: Math.trunc((point.y - previous.y) * current.height / previous.height + current.y)
+      };
+      return Math.abs(next2.x - point.x) >= 80 || Math.abs(next2.y - point.y) >= 80 ? point : next2;
+    }
+    if (previous.width === 0) return point;
+    const next = {
+      // FloorCeiling.java performs integer division before applying the
+      // mascot's relative offset along a resized border.
+      x: (point.x - previous.x) * Math.trunc(current.width / previous.width) + current.x,
+      y: point.y + this.coordinate(current) - this.coordinate(previous)
+    };
+    return Math.abs(next.x - point.x) >= 80 || next.y - point.y > 20 || next.y - point.y < -80 ? point : next;
+  }
+  isOn(point, context) {
+    const rectangle = this.rectangle(context);
+    if (!rectangle) return false;
+    switch (this.side) {
+      case "top":
+        return isOnTop(point, rectangle);
+      case "bottom":
+        return isOnBottom(point, rectangle);
+      case "left":
+        return isOnLeft(point, rectangle);
+      case "right":
+        return isOnRight(point, rectangle);
+    }
+  }
+  coordinate(rectangle) {
+    switch (this.side) {
+      case "top":
+        return rectangle.y;
+      case "bottom":
+        return rectangle.y + rectangle.height;
+      case "left":
+        return rectangle.x;
+      case "right":
+        return rectangle.x + rectangle.width;
+    }
+  }
+  rectangle(context) {
+    if (this.source === "work-area") return context.bounds;
+    if (!this.source) return void 0;
+    return context.platforms.find((platform) => platform.element === this.source);
+  }
+};
+function selectBorder(type, state, context) {
+  if (type === "Floor") {
+    const platform2 = context.platforms.find((candidate) => isOnTop(state, candidate));
+    if (platform2) return new TrackedBorder("top", platform2.element, context);
+    if (isOnBottom(state, context.bounds)) return new TrackedBorder("bottom", "work-area", context);
+    return new TrackedBorder("bottom", void 0, context);
+  }
+  if (type === "Ceiling") {
+    const platform2 = context.platforms.find((candidate) => isOnBottom(state, candidate));
+    if (platform2) return new TrackedBorder("bottom", platform2.element, context);
+    if (isOnTop(state, context.bounds)) return new TrackedBorder("top", "work-area", context);
+    return new TrackedBorder("top", void 0, context);
+  }
+  if (state.lookRight) {
+    const platform2 = context.platforms.find((candidate) => isOnLeft(state, candidate));
+    if (platform2) return new TrackedBorder("left", platform2.element, context);
+    if (isOnRight(state, context.bounds)) return new TrackedBorder("right", "work-area", context);
+    return new TrackedBorder("right", void 0, context);
+  }
+  const platform = context.platforms.find((candidate) => isOnRight(state, candidate));
+  if (platform) return new TrackedBorder("right", platform.element, context);
+  if (isOnLeft(state, context.bounds)) return new TrackedBorder("left", "work-area", context);
+  return new TrackedBorder("left", void 0, context);
 }
-var SequenceRuntime = class {
-  constructor(definitions, factory, loop) {
-    this.definitions = definitions;
-    this.factory = factory;
-    this.loop = loop;
+var AnimatedRuntime = class extends RuntimeBase {
+  constructor(definition, state, random) {
+    super(definition, random);
+    this.state = state;
   }
-  definitions;
-  factory;
-  loop;
-  index = 0;
-  child;
-  tick(deltaMs, environment, bounds) {
-    for (let guard = 0; guard < 32; guard += 1) {
-      const definition = this.definitions[this.index];
-      if (!definition) {
-        if (!this.loop || this.definitions.length === 0) return true;
-        this.index = 0;
-        continue;
-      }
-      this.child ??= this.factory(definition, environment);
-      if (!this.child.tick(deltaMs, environment, bounds)) return false;
-      this.child = void 0;
-      this.index += 1;
-      deltaMs = 0;
+  state;
+  border;
+  onInit(context) {
+    this.border = this.definition.borderType ? selectBorder(this.definition.borderType, this.state, context) : void 0;
+  }
+  animation(context, turn) {
+    const scoped = this.scopedEnvironment(context.environment);
+    return this.definition.animations?.find((animation, index) => (turn === void 0 || Boolean(animation.turn) === turn) && this.values.boolean(`animation-${index}`, animation.condition, scoped, true));
+  }
+  animationDuration(context, turn) {
+    return this.animation(context, turn)?.poses.reduce((sum, pose) => sum + Math.max(0, pose.duration), 0) ?? 0;
+  }
+  applyBorder(context) {
+    if (!this.border) return "running";
+    const moved = this.border.move(this.state, context);
+    this.state.x = moved.x;
+    this.state.y = moved.y;
+    return this.border.isOn(this.state, context) ? "running" : "lost-ground";
+  }
+  applyAnimation(context, turn) {
+    const animation = this.animation(context, turn);
+    const pose = animation && poseAt(animation, this.time);
+    if (pose) applyPose(this.state, pose);
+  }
+  scopedEnvironment(environment) {
+    const gap = this.values.number("gap", this.definition.gap, environment, 0);
+    const withGap = { ...environment, gap };
+    const targetX = this.definition.targetX === void 0 ? void 0 : this.values.number("targetX", this.definition.targetX, withGap, 0);
+    const targetY = this.definition.targetY === void 0 ? void 0 : this.values.number("targetY", this.definition.targetY, withGap, 0);
+    return { ...withGap, ...targetX !== void 0 && { targetX }, ...targetY !== void 0 && { targetY } };
+  }
+};
+function poseAt(animation, time) {
+  const duration = animation.poses.reduce((sum, pose) => sum + Math.max(0, pose.duration), 0);
+  if (duration <= 0) return void 0;
+  let cursor = time % duration;
+  for (const pose of animation.poses) {
+    cursor -= Math.max(0, pose.duration);
+    if (cursor < 0) return pose;
+  }
+  return animation.poses.at(-1);
+}
+function applyPose(state, pose) {
+  state.sprite = pose.sprite;
+  state.anchorX = pose.anchor.x;
+  state.anchorY = pose.anchor.y;
+  state.x += (state.lookRight ? -1 : 1) * pose.velocity.x;
+  state.y += pose.velocity.y;
+}
+var StayRuntime = class extends AnimatedRuntime {
+  tick(context) {
+    const border = this.applyBorder(context);
+    if (border === "lost-ground") return border;
+    this.applyAnimation(context);
+    return "running";
+  }
+};
+var AnimateRuntime = class extends StayRuntime {
+  hasMore(context) {
+    return this.time < this.animationDuration(context);
+  }
+};
+var MoveRuntime = class extends AnimatedRuntime {
+  turning = false;
+  hasTurningAnimation = false;
+  onInit(context) {
+    super.onInit(context);
+    this.turning = false;
+    this.hasTurningAnimation = this.definition.animations?.some((animation) => animation.turn) ?? false;
+  }
+  hasMore(context) {
+    const scoped = this.scopedEnvironment(context.environment);
+    const targetX = this.targetX(scoped);
+    const targetY = this.targetY(scoped);
+    const reached = targetX !== void 0 && this.state.x === targetX || targetY !== void 0 && this.state.y === targetY;
+    return !reached || this.turning;
+  }
+  tick(context) {
+    const border = this.applyBorder(context);
+    if (border === "lost-ground") return border;
+    const scoped = this.scopedEnvironment(context.environment);
+    const targetX = this.targetX(scoped);
+    const targetY = this.targetY(scoped);
+    let down = false;
+    if (targetX !== void 0 && this.state.x !== targetX) {
+      const nextLookRight = this.state.x < targetX;
+      this.turning = this.hasTurningAnimation && (this.turning || nextLookRight !== this.state.lookRight);
+      this.state.lookRight = nextLookRight;
     }
-    return false;
+    if (targetY !== void 0) down = this.state.y < targetY;
+    if (this.turning && this.time >= this.animationDuration(context, true)) this.turning = false;
+    this.applyAnimation(context, this.turning);
+    if (targetX !== void 0 && (this.state.lookRight && this.state.x >= targetX || !this.state.lookRight && this.state.x <= targetX)) this.state.x = targetX;
+    if (targetY !== void 0 && (down && this.state.y >= targetY || !down && this.state.y <= targetY)) this.state.y = targetY;
+    return "running";
+  }
+  targetX(environment) {
+    return this.definition.targetX === void 0 ? void 0 : Math.trunc(this.values.number("targetX", this.definition.targetX, environment, 0));
+  }
+  targetY(environment) {
+    return this.definition.targetY === void 0 ? void 0 : Math.trunc(this.values.number("targetY", this.definition.targetY, environment, 0));
   }
 };
-var CompleteRuntime = class {
+var MoveWithTurnRuntime = class extends MoveRuntime {
+  onInit(context) {
+    super.onInit(context);
+    this.hasTurningAnimation = (this.definition.animations?.length ?? 0) >= 2;
+  }
+  animation(context, turn) {
+    const animations = this.definition.animations ?? [];
+    if (turn) return animations.at(-1);
+    const scoped = this.scopedEnvironment(context.environment);
+    return animations.slice(0, -1).find((candidate, index) => this.values.boolean(`animation-${index}`, candidate.condition, scoped, true));
+  }
+};
+var TurnRuntime = class extends AnimatedRuntime {
+  turning = false;
+  hasMore(context) {
+    const desired = this.values.boolean("lookRight", this.definition.lookRight, context.environment, !this.state.lookRight);
+    this.turning ||= desired !== this.state.lookRight;
+    return this.turning && this.time < this.animationDuration(context);
+  }
+  tick(context) {
+    this.state.lookRight = this.values.boolean("lookRight", this.definition.lookRight, context.environment, !this.state.lookRight);
+    const border = this.applyBorder(context);
+    if (border === "lost-ground") return border;
+    this.applyAnimation(context);
+    return "running";
+  }
+};
+var InstantRuntime = class extends RuntimeBase {
+  constructor(definition, state, random, operation) {
+    super(definition, random);
+    this.state = state;
+    this.operation = operation;
+  }
+  state;
+  operation;
+  onInit(context) {
+    if (!this.baseHasNext(context)) return;
+    if (this.operation === "look") {
+      this.state.lookRight = this.values.boolean("lookRight", this.definition.lookRight, context.environment, !this.state.lookRight);
+    } else if (this.operation === "offset") {
+      this.state.x += Math.trunc(this.values.number("x", this.definition.x, context.environment, 0));
+      this.state.y += Math.trunc(this.values.number("y", this.definition.y, context.environment, 0));
+    }
+  }
+  hasMore() {
+    return false;
+  }
   tick() {
-    return true;
+    return "running";
   }
 };
-var LeafRuntime = class {
-  constructor(action, state, options, callbacks, environment) {
-    this.action = action;
+var JumpRuntime = class extends RuntimeBase {
+  constructor(definition, state, random) {
+    super(definition, random);
     this.state = state;
-    this.options = options;
-    this.callbacks = callbacks;
-    const animationEnvironment = { ...environment, ...action.targetX !== void 0 && { targetX: action.targetX }, ...action.targetY !== void 0 && { targetY: action.targetY } };
-    this.animation = action.definition.animations?.find((animation) => !animation.condition || evaluateExpression(animation.condition, animationEnvironment, false)) ?? action.definition.animations?.find((animation) => !animation.condition) ?? action.definition.animations?.[0];
-    this.poseDuration = this.animation?.poses.reduce((sum, pose) => sum + Math.max(0, pose.duration), 0) ?? 0;
   }
-  action;
   state;
-  options;
-  callbacks;
-  elapsedMs = 0;
-  started = false;
-  spawned = false;
-  animation;
-  poseDuration;
-  tick(deltaMs, environment, bounds) {
-    const frameScale = deltaMs / this.options.frameDuration;
-    if (!this.started) {
-      this.started = true;
-      this.state.lookRight = this.action.lookRight;
-      this.initialize();
+  hasMore(context) {
+    return this.distance(context).distance !== 0;
+  }
+  tick(context) {
+    const { targetX, targetY, distanceX, distanceY, distance } = this.distance(context);
+    this.state.lookRight = this.state.x < targetX;
+    const velocity = this.values.number("velocity", this.definition.velocity, context.environment, 20);
+    if (distance !== 0) {
+      this.state.vx = velocity * distanceX / distance;
+      this.state.vy = velocity * distanceY / distance;
+      this.state.x += Math.trunc(this.state.vx);
+      this.state.y += Math.trunc(this.state.vy);
+      const environment = { ...context.environment, targetX, targetY };
+      const animation = this.definition.animations?.find((candidate, index) => this.values.boolean(`animation-${index}`, candidate.condition, environment, true));
+      const pose = animation && poseAt(animation, this.time);
+      if (pose) applyPose(this.state, pose);
     }
-    this.elapsedMs += deltaMs;
-    const pose = this.currentPose();
-    if (pose) this.applyPose(pose, frameScale, bounds);
-    const { definition } = this.action;
-    if (definition.type === "Embedded") return this.tickEmbedded(frameScale, environment, bounds);
-    if (definition.type === "Move" && (this.action.targetX !== void 0 || this.action.targetY !== void 0)) {
-      const reachedX = this.action.targetX === void 0 || Math.abs(this.state.x - this.action.targetX) < 0.5;
-      const reachedY = this.action.targetY === void 0 || Math.abs(this.state.y - this.action.targetY) < 0.5;
-      return reachedX && reachedY;
+    if (distance <= velocity) {
+      this.state.x = targetX;
+      this.state.y = targetY;
     }
-    return this.elapsedMs >= this.durationMs();
+    return "running";
   }
-  initialize() {
-    const type = this.action.definition.embedType;
-    if (type === "Fall" || type === "FallWithIE") {
-      this.state.vx = this.action.initialVx ?? this.state.vx;
-      this.state.vy = this.action.initialVy ?? this.state.vy;
-    }
-    if (type === "Offset") {
-      this.state.x += this.action.x ?? 0;
-      this.state.y += this.action.y ?? 0;
+  distance(context) {
+    const targetX = Math.trunc(this.values.number("targetX", this.definition.targetX, context.environment, 0));
+    const targetY = Math.trunc(this.values.number("targetY", this.definition.targetY, context.environment, 0));
+    const distanceX = targetX - this.state.x;
+    const distanceY = targetY - this.state.y - Math.abs(distanceX) / 2;
+    return { targetX, targetY, distanceX, distanceY, distance: Math.hypot(distanceX, distanceY) };
+  }
+};
+var FallRuntime = class extends RuntimeBase {
+  constructor(definition, state, random, defaultGravity) {
+    super(definition, random);
+    this.state = state;
+    this.defaultGravity = defaultGravity;
+  }
+  state;
+  defaultGravity;
+  modX = 0;
+  modY = 0;
+  onInit(context) {
+    this.modX = 0;
+    this.modY = 0;
+    this.state.vx = Math.trunc(this.values.number("initialVx", this.definition.initialVx, context.environment, 0));
+    this.state.vy = Math.trunc(this.values.number("initialVy", this.definition.initialVy, context.environment, 0));
+  }
+  hasMore(context) {
+    return !isOnFloor(this.state, context.bounds, context.platforms) && !isOnWall(this.state, context.bounds, this.state.lookRight, context.platforms);
+  }
+  tick(context) {
+    if (this.state.vx !== 0) this.state.lookRight = this.state.vx > 0;
+    const resistanceX = this.values.number("resistanceX", this.definition.resistanceX, context.environment, 0.05);
+    const resistanceY = this.values.number("resistanceY", this.definition.resistanceY, context.environment, 0.1);
+    const gravity = this.values.number("gravity", this.definition.gravity, context.environment, this.defaultGravity);
+    this.state.vx -= this.state.vx * resistanceX;
+    this.state.vy = this.state.vy - this.state.vy * resistanceY + gravity;
+    this.modX += this.state.vx % 1;
+    this.modY += this.state.vy % 1;
+    const dx = Math.trunc(this.state.vx) + Math.trunc(this.modX);
+    const dy = Math.trunc(this.state.vy) + Math.trunc(this.modY);
+    this.modX %= 1;
+    this.modY %= 1;
+    const divisions = Math.max(1, Math.abs(dx), Math.abs(dy));
+    const start = { x: this.state.x, y: this.state.y };
+    let stopped = false;
+    for (let index = 0; index <= divisions; index += 1) {
+      const x = start.x + Math.trunc(dx * index / divisions);
+      const y = start.y + Math.trunc(dy * index / divisions);
+      this.state.x = x;
+      this.state.y = y;
+      if (dy > 0) {
+        for (let offset = -80; offset <= 0; offset += 1) {
+          this.state.y = y + offset;
+          if (isOnFloor(this.state, context.bounds, context.platforms)) {
+            stopped = true;
+            break;
+          }
+        }
+        if (stopped) break;
+        this.state.y = y;
+      }
+      if (isOnWall(this.state, context.bounds, this.state.lookRight, context.platforms)) break;
     }
-    if (type === "Reboot") {
-      this.state.vx = 0;
-      this.state.vy = 0;
+    const fallEnvironment = { ...context.environment, velocityX: this.state.vx, velocityY: this.state.vy };
+    const animation = this.definition.animations?.find((candidate, index) => this.values.boolean(`animation-${index}`, candidate.condition, fallEnvironment, true));
+    const pose = animation && poseAt(animation, this.time);
+    if (pose) applyPose(this.state, pose);
+    return "running";
+  }
+};
+function matchingActivePlatform(context) {
+  const active = context.environment.mascot.environment.activeIE;
+  if (!active.visible) return void 0;
+  return context.platforms.find((platform) => Math.abs(platform.x - active.x) < 1e-3 && Math.abs(platform.y - active.y) < 1e-3 && Math.abs(platform.width - active.width) < 1e-3 && Math.abs(platform.height - active.height) < 1e-3);
+}
+function carryRelation(state, platform, offsetX, offsetY) {
+  const grip = {
+    x: state.x + (state.lookRight ? -offsetX : offsetX),
+    y: state.y + offsetY
+  };
+  return isOnBottom(grip, platform) && (state.lookRight ? isOnLeft(grip, platform) : isOnRight(grip, platform));
+}
+function carriedPlatformPosition(state, platform, offsetX, offsetY) {
+  return state.lookRight ? { x: state.x - offsetX, y: state.y + offsetY - platform.height } : { x: state.x + offsetX - platform.width, y: state.y + offsetY - platform.height };
+}
+var CarryFallRuntime = class extends FallRuntime {
+  constructor(definition, state, random, gravity, callbacks) {
+    super(definition, state, random, gravity);
+    this.callbacks = callbacks;
+  }
+  callbacks;
+  element;
+  onInit(context) {
+    super.onInit(context);
+    this.element = matchingActivePlatform(context)?.element;
+  }
+  tick(context) {
+    const platform = context.platforms.find((candidate) => candidate.element === this.element);
+    const offsetX = Math.trunc(this.values.number("ieOffsetX", this.definition.ieOffsetX, context.environment, 0));
+    const offsetY = Math.trunc(this.values.number("ieOffsetY", this.definition.ieOffsetY, context.environment, 0));
+    if (!platform || !carryRelation(this.state, platform, offsetX, offsetY)) return "lost-ground";
+    const result = super.tick(context);
+    this.callbacks.movePlatform?.(platform.element, carriedPlatformPosition(this.state, platform, offsetX, offsetY));
+    return result;
+  }
+};
+var CarryMoveRuntime = class extends MoveRuntime {
+  constructor(definition, state, random, callbacks) {
+    super(definition, state, random);
+    this.callbacks = callbacks;
+  }
+  callbacks;
+  element;
+  onInit(context) {
+    super.onInit(context);
+    this.element = matchingActivePlatform(context)?.element;
+  }
+  tick(context) {
+    const platform = context.platforms.find((candidate) => candidate.element === this.element);
+    const offsetX = Math.trunc(this.values.number("ieOffsetX", this.definition.ieOffsetX, context.environment, 0));
+    const offsetY = Math.trunc(this.values.number("ieOffsetY", this.definition.ieOffsetY, context.environment, 0));
+    if (!platform || !carryRelation(this.state, platform, offsetX, offsetY)) return "lost-ground";
+    const result = super.tick(context);
+    this.callbacks.movePlatform?.(platform.element, carriedPlatformPosition(this.state, platform, offsetX, offsetY));
+    return result;
+  }
+};
+var ThrowPlatformRuntime = class extends AnimateRuntime {
+  constructor(definition, state, random, callbacks) {
+    super(definition, state, random);
+    this.callbacks = callbacks;
+  }
+  callbacks;
+  element;
+  onInit(context) {
+    super.onInit(context);
+    this.element = matchingActivePlatform(context)?.element;
+  }
+  tick(context) {
+    const result = super.tick(context);
+    const platform = context.platforms.find((candidate) => candidate.element === this.element);
+    if (platform) {
+      const vx = Math.trunc(this.values.number("initialVx", this.definition.initialVx, context.environment, 32));
+      const vy = Math.trunc(this.values.number("initialVy", this.definition.initialVy, context.environment, -10));
+      const gravity = this.values.number("gravity", this.definition.gravity, context.environment, 0.5);
+      this.callbacks.movePlatform?.(platform.element, {
+        x: platform.x + (this.state.lookRight ? vx : -vx),
+        y: platform.y + vy + Math.trunc(this.time * gravity)
+      });
     }
+    return result;
   }
-  tickEmbedded(frameScale, environment, bounds) {
-    switch (this.action.definition.embedType) {
-      case "Fall":
-      case "FallWithIE":
-      case "Thrown":
-        return applyGravity(
-          this.state,
-          bounds,
-          frameScale,
-          this.action.gravity ?? this.options.gravity,
-          this.action.resistanceX,
-          this.action.resistanceY,
-          environment.mascot.environment.activeIE.visible ? environment.mascot.environment.activeIE : void 0
-        );
-      case "Jump": {
-        const target = { x: this.action.targetX ?? this.state.x, y: this.action.targetY ?? this.state.y };
-        return moveToward(this.state, target, this.action.velocity ?? 20, frameScale);
-      }
-      case "Breed":
-        if (!this.spawned && this.elapsedMs >= this.durationMs()) {
-          this.spawned = true;
-          const child = { x: this.state.x + (this.action.bornX ?? 0), y: this.state.y + (this.action.bornY ?? 0) };
-          this.callbacks.spawn(this.action.definition.bornBehavior ? { ...child, behaviorName: this.action.definition.bornBehavior } : child);
-          return true;
-        }
-        return false;
-      case "Exit":
-        this.callbacks.remove();
-        return true;
-      case "Reboot":
-        this.state.x = bounds.x + 128 + Math.max(0, bounds.width - 256) * Math.random();
-        this.state.y = bounds.y + 128 + Math.max(0, bounds.height - 256) * Math.random();
-        return true;
-      case "Offset":
-      case "Look":
-        return true;
-      case "Dragged":
-        return false;
-      default:
-        return this.elapsedMs >= this.durationMs();
+};
+function breed(definition, state, values, context, callbacks) {
+  const bornX = Math.trunc(values.number("bornX", definition.bornX, context.environment, 0));
+  const bornY = Math.trunc(values.number("bornY", definition.bornY, context.environment, 0));
+  const count = Math.trunc(values.number("bornCount", definition.bornCount, context.environment, 1));
+  if (count < 1) throw new RangeError("BornCount must be positive");
+  for (let index = 0; index < count; index += 1) {
+    callbacks.spawn({
+      x: state.x + (state.lookRight ? -bornX : bornX),
+      y: state.y + bornY,
+      lookRight: state.lookRight,
+      ...definition.bornBehavior && { behaviorName: definition.bornBehavior }
+    }, definition.bornMascot);
+  }
+}
+var BreedRuntime = class extends AnimateRuntime {
+  constructor(definition, state, random, callbacks) {
+    super(definition, state, random);
+    this.callbacks = callbacks;
+  }
+  callbacks;
+  spawned = false;
+  tick(context) {
+    const result = super.tick(context);
+    if (result === "lost-ground") return result;
+    const duration = this.animationDuration(context);
+    if (!this.spawned && this.time === duration - 1) {
+      this.spawned = true;
+      breed(this.definition, this.state, this.values, context, this.callbacks);
     }
+    return result;
+  }
+};
+var BreedMoveRuntime = class extends MoveRuntime {
+  constructor(definition, state, random, callbacks) {
+    super(definition, state, random);
+    this.callbacks = callbacks;
+  }
+  callbacks;
+  tick(context) {
+    const result = super.tick(context);
+    if (result === "lost-ground") return result;
+    const interval = Math.trunc(this.values.number("bornInterval", this.definition.bornInterval, context.environment, 1));
+    if (interval < 1) throw new RangeError("BornInterval must be positive");
+    if (this.time % interval === 0 && !this.turning) breed(this.definition, this.state, this.values, context, this.callbacks);
+    return result;
+  }
+};
+var BreedJumpRuntime = class extends JumpRuntime {
+  constructor(definition, breedState, random, callbacks) {
+    super(definition, breedState, random);
+    this.breedState = breedState;
+    this.callbacks = callbacks;
   }
-  currentPose() {
-    if (!this.animation?.poses.length || this.poseDuration <= 0) return void 0;
-    let cursor = this.elapsedMs / this.options.frameDuration % this.poseDuration;
-    for (const pose of this.animation.poses) {
-      cursor -= pose.duration;
-      if (cursor < 0) return pose;
+  breedState;
+  callbacks;
+  tick(context) {
+    const result = super.tick(context);
+    const interval = Math.trunc(this.values.number("bornInterval", this.definition.bornInterval, context.environment, 1));
+    if (interval < 1) throw new RangeError("BornInterval must be positive");
+    if (this.time % interval === 0) breed(this.definition, this.breedState, this.values, context, this.callbacks);
+    return result;
+  }
+};
+var DraggedRuntime = class extends RuntimeBase {
+  constructor(definition, state, random, spec) {
+    super(definition, random);
+    this.state = state;
+    this.spec = spec;
+  }
+  state;
+  spec;
+  footX = 0;
+  footDx = 0;
+  timeToRegist = 250;
+  onInit(context) {
+    this.footDx = 0;
+    this.timeToRegist = 250;
+    this.footX = context.environment.mascot.environment.cursor.x + this.offsetX(context);
+  }
+  hasMore() {
+    return this.time < this.timeToRegist;
+  }
+  tick(context) {
+    this.state.lookRight = false;
+    this.state.dragging = true;
+    const cursor = context.environment.mascot.environment.cursor;
+    const offsetX = this.offsetX(context);
+    const offsetY = this.offsetY(context);
+    if (Math.abs(cursor.x - this.state.x + offsetX) >= 5) this.time = 0;
+    this.footDx = (this.footDx + (cursor.x - this.footX) * 0.1) * 0.8;
+    this.footX += this.footDx;
+    const environment = { ...context.environment, footX: this.footX };
+    const animation = this.definition.animations?.find((candidate, index) => this.values.boolean(`animation-${index}`, candidate.condition, environment, true));
+    const pose = animation && poseAt(animation, this.time);
+    if (pose) applyPose(this.state, pose);
+    this.state.x = cursor.x + offsetX;
+    this.state.y = cursor.y + offsetY;
+    if (this.time === this.timeToRegist - 1 && this.values.number(`regist-${this.time}`, "#{Math.random()}", environment, 0) >= 0.1) this.timeToRegist += 1;
+    return "running";
+  }
+  offsetX(context) {
+    const offset = Math.trunc(this.values.number("offsetX", this.definition.offsetX, context.environment, 0));
+    return this.definition.offsetType === "Origin" ? -offset + this.spriteCenter().x : offset;
+  }
+  offsetY(context) {
+    const offset = Math.trunc(this.values.number("offsetY", this.definition.offsetY, context.environment, 120));
+    return this.definition.offsetType === "Origin" ? -offset + this.spriteCenter().y : offset;
+  }
+  spriteCenter() {
+    const sprite = this.spec.sprites[this.state.sprite];
+    const width = typeof sprite === "object" ? sprite.width ?? 128 : 128;
+    return { x: this.state.lookRight ? width - this.state.anchorX : this.state.anchorX, y: this.state.anchorY };
+  }
+};
+var RegistRuntime = class extends AnimatedRuntime {
+  constructor(definition, state, random, spec) {
+    super(definition, state, random);
+    this.spec = spec;
+  }
+  spec;
+  hasMore(context) {
+    const cursor = context.environment.mascot.environment.cursor;
+    const rawOffset = Math.trunc(this.values.number("offsetX", this.definition.offsetX, context.environment, 0));
+    const sprite = this.spec.sprites[this.state.sprite];
+    const width = typeof sprite === "object" ? sprite.width ?? 128 : 128;
+    const centerX = this.state.lookRight ? width - this.state.anchorX : this.state.anchorX;
+    const offsetX = this.definition.offsetType === "Origin" ? -rawOffset + centerX : rawOffset;
+    return Math.abs(cursor.x - this.state.x + offsetX) < 5;
+  }
+  tick(context) {
+    this.state.dragging = true;
+    this.applyAnimation(context);
+    if (this.time + 1 >= this.animationDuration(context)) {
+      this.state.lookRight = this.values.number(`look-${this.time}`, "#{Math.random()}", context.environment, 0) < 0.5;
+      return "lost-ground";
     }
-    return this.animation.poses.at(-1);
+    return "running";
   }
-  applyPose(pose, frameScale, bounds) {
-    this.state.sprite = pose.sprite;
-    this.state.anchorX = pose.anchor.x;
-    this.state.anchorY = pose.anchor.y;
-    const direction = this.state.lookRight ? -1 : 1;
-    this.state.x = clamp(this.state.x + pose.velocity.x * direction * frameScale, bounds.x, bounds.x + bounds.width);
-    this.state.y = clamp(this.state.y + pose.velocity.y * frameScale, bounds.y, bounds.y + bounds.height);
+};
+var SelfDestructRuntime = class extends AnimateRuntime {
+  constructor(definition, state, random, callbacks) {
+    super(definition, state, random);
+    this.callbacks = callbacks;
+  }
+  callbacks;
+  tick(context) {
+    const result = super.tick(context);
+    if (this.time === this.animationDuration(context) - 1) this.callbacks.remove();
+    return result;
+  }
+};
+var ComplexRuntime = class extends RuntimeBase {
+  constructor(definition, random, factory, selectOnly) {
+    super(definition, random);
+    this.factory = factory;
+    this.selectOnly = selectOnly;
   }
-  durationMs() {
-    const frames = this.action.duration ?? this.poseDuration;
-    return Math.max(this.options.frameDuration, frames * this.options.frameDuration);
+  factory;
+  selectOnly;
+  index = 0;
+  child;
+  selectionMade = false;
+  onInit(context) {
+    this.index = 0;
+    this.child = void 0;
+    this.selectionMade = false;
+    if (this.baseHasNext(context)) this.seek(context);
+  }
+  hasMore(context) {
+    if (!this.selectOnly) this.seek(context);
+    return this.child?.hasNext(context) ?? false;
+  }
+  tick(context) {
+    return this.child?.hasNext(context) ? this.child.step(context) : "running";
+  }
+  seek(context) {
+    const definitions = this.definition.actions ?? [];
+    if (definitions.length === 0) return;
+    for (let guard = 0; guard <= definitions.length; guard += 1) {
+      if (this.child?.hasNext(context)) {
+        this.selectionMade = true;
+        return;
+      }
+      if (this.selectOnly && this.selectionMade) {
+        this.child = void 0;
+        return;
+      }
+      if (this.index >= definitions.length) {
+        if (this.definition.loop !== true) {
+          this.child = void 0;
+          return;
+        }
+        this.index = 0;
+      }
+      const definition = definitions[this.index++];
+      if (!definition) {
+        this.child = void 0;
+        return;
+      }
+      this.child = this.factory(definition, context);
+      this.child.init(context);
+    }
+    this.child = void 0;
   }
 };
 var ActionExecutor = class {
-  /** Creates an executor bound to one mascot's mutable internal state. */
   constructor(spec, state, options, callbacks) {
     this.spec = spec;
     this.state = state;
     this.options = options;
     this.callbacks = callbacks;
+    this.random = options.random ?? Math.random;
   }
   spec;
   state;
   options;
   callbacks;
   runtime;
+  accumulator = 0;
+  random;
   /** Starts the action whose name matches a selected behavior. */
-  start(actionName, environment) {
+  start(actionName, environment, _preserveLookRight = false, bounds = environment.mascot.environment.workArea, platforms = []) {
     const definition = this.spec.actions.find((action) => action.name === actionName);
-    this.runtime = definition ? this.createRuntime(definition, environment, /* @__PURE__ */ new Set()) : void 0;
-    return this.runtime !== void 0;
+    this.accumulator = 0;
+    if (!definition) {
+      this.runtime = void 0;
+      return false;
+    }
+    const context = { environment, bounds, platforms };
+    this.runtime = this.createRuntime(definition, context, /* @__PURE__ */ new Set());
+    this.runtime.init(context);
+    return true;
   }
-  /** Advances the current action and returns true when it has completed. */
-  tick(deltaMs, environment, bounds) {
-    return this.runtime?.tick(deltaMs, environment, bounds) ?? true;
+  /** Advances by elapsed milliseconds and reports completion. */
+  tick(deltaMs, environment, bounds, platforms = []) {
+    this.accumulator += Math.max(0, deltaMs);
+    let result = this.runtime?.hasNext({ environment, bounds, platforms }) ? "running" : "complete";
+    while (this.accumulator >= this.options.frameDuration && result === "running") {
+      this.accumulator -= this.options.frameDuration;
+      result = this.step(environment, bounds, platforms);
+    }
+    return result !== "running";
+  }
+  /** Advances exactly one legacy frame. */
+  step(environment, bounds, platforms = []) {
+    const context = { environment, bounds, platforms };
+    if (!this.runtime?.hasNext(context)) return "complete";
+    const result = this.runtime.step(context);
+    if (result === "lost-ground") return result;
+    return this.runtime.hasNext(context) ? "running" : "complete";
+  }
+  /** Returns whether the current action can execute another legacy frame. */
+  hasNext(environment, bounds, platforms = []) {
+    return this.runtime?.hasNext({ environment, bounds, platforms }) ?? false;
+  }
+  /** Retained for source compatibility with the previous collision API. */
+  consumeViewportWallCollision() {
+    return false;
   }
   /** Cancels the current action tree. */
   cancel() {
     this.runtime = void 0;
+    this.accumulator = 0;
   }
-  createRuntime(definition, environment, references) {
-    if (definition.condition && !evaluateExpression(definition.condition, environment, false)) return new CompleteRuntime();
-    const bounds = environment.mascot.environment.workArea;
-    const activeIE = environment.mascot.environment.activeIE;
-    if (!isOnBorder(this.state, bounds, definition.borderType, activeIE.visible ? activeIE : void 0)) return new CompleteRuntime();
+  createRuntime(definition, context, references) {
     if (definition.type === "Reference") {
-      if (!definition.name || references.has(definition.name)) return new CompleteRuntime();
+      if (!definition.name || references.has(definition.name)) return new InstantRuntime(definition, this.state, this.random, "noop");
       const referenced = this.spec.actions.find((action) => action.name === definition.name);
-      if (!referenced) return new CompleteRuntime();
-      const nextReferences = new Set(references).add(definition.name);
-      return this.createRuntime({ ...referenced, ...definition, type: referenced.type }, environment, nextReferences);
+      if (!referenced) return new InstantRuntime(definition, this.state, this.random, "noop");
+      return this.createRuntime({ ...referenced, ...definition, type: referenced.type, name: definition.name }, context, new Set(references).add(definition.name));
     }
-    if (definition.type === "Sequence") {
-      return new SequenceRuntime(definition.actions ?? [], (child, nextEnvironment) => this.createRuntime(child, nextEnvironment, new Set(references)), definition.loop === true);
+    if (definition.type === "Sequence" || definition.type === "Select") {
+      return new ComplexRuntime(definition, this.random, (child, nextContext) => this.createRuntime(child, nextContext, new Set(references)), definition.type === "Select");
     }
-    if (definition.type === "Select") {
-      const child = definition.actions?.find((candidate) => !candidate.condition || evaluateExpression(candidate.condition, environment, false));
-      return child ? this.createRuntime(child, environment, new Set(references)) : new CompleteRuntime();
+    if (definition.type === "Stay") return new StayRuntime(definition, this.state, this.random);
+    if (definition.type === "Animate") return new AnimateRuntime(definition, this.state, this.random);
+    if (definition.type === "Move") return new MoveRuntime(definition, this.state, this.random);
+    switch (definition.embedType) {
+      case "Fall":
+        return new FallRuntime(definition, this.state, this.random, this.options.gravity);
+      case "FallWithIE":
+        return new CarryFallRuntime(definition, this.state, this.random, this.options.gravity, this.callbacks);
+      case "Jump":
+      case "ComplexJump":
+      case "ScanJump":
+      case "BroadcastJump":
+        return new JumpRuntime(definition, this.state, this.random);
+      case "WalkWithIE":
+        return new CarryMoveRuntime(definition, this.state, this.random, this.callbacks);
+      case "MoveWithTurn":
+        return new MoveWithTurnRuntime(definition, this.state, this.random);
+      case "ComplexMove":
+      case "ScanMove":
+      case "BroadcastMove":
+        return new MoveRuntime(definition, this.state, this.random);
+      case "Turn":
+        return new TurnRuntime(definition, this.state, this.random);
+      case "Look":
+        return new InstantRuntime(definition, this.state, this.random, "look");
+      case "Offset":
+        return new InstantRuntime(definition, this.state, this.random, "offset");
+      case "Mute":
+      case "Reboot":
+        return new InstantRuntime(definition, this.state, this.random, "noop");
+      case "Breed":
+        return new BreedRuntime(definition, this.state, this.random, this.callbacks);
+      case "BreedMove":
+        return new BreedMoveRuntime(definition, this.state, this.random, this.callbacks);
+      case "BreedJump":
+        return new BreedJumpRuntime(definition, this.state, this.random, this.callbacks);
+      case "ThrowIE":
+        return new ThrowPlatformRuntime(definition, this.state, this.random, this.callbacks);
+      case "SelfDestruct":
+      case "Exit":
+        return new SelfDestructRuntime(definition, this.state, this.random, this.callbacks);
+      case "Dragged":
+        return new DraggedRuntime(definition, this.state, this.random, this.spec);
+      case "Regist":
+        return new RegistRuntime(definition, this.state, this.random, this.spec);
+      case "Broadcast":
+      case "Interact":
+      case "ScanInteract":
+      case "Transform":
+        return new AnimateRuntime(definition, this.state, this.random);
+      case "BroadcastStay":
+        return new StayRuntime(definition, this.state, this.random);
+      default:
+        return new StayRuntime(definition, this.state, this.random);
     }
-    return new LeafRuntime(evaluateAction(definition, environment), this.state, this.options, this.callbacks, environment);
   }
 };
 
@@ -977,7 +1637,6 @@ function environmentRectangle(bounds) {
   };
 }
 var PLATFORM_NEARBY_DISTANCE = 400;
-var PLATFORM_EDGE_TOLERANCE = 16;
 function distanceToRectangle(point, rectangle) {
   const dx = Math.max(rectangle.x - point.x, 0, point.x - rectangle.x - rectangle.width);
   const dy = Math.max(rectangle.y - point.y, 0, point.y - rectangle.y - rectangle.height);
@@ -1006,10 +1665,14 @@ var Mascot = class {
       dragging: false
     };
     this.domHandle = dom.createMascot(spec, id, options.mascotClassName || void 0);
+    this.frameDuration = options.frameDuration;
+    this.random = options.random ?? Math.random;
+    this.forceInitialFall = spawnOptions.behaviorName === void 0;
     this.behavior = new BehaviorController(spec, options.random);
     this.actions = new ActionExecutor(spec, this.state, options, {
-      spawn: (position) => this.callbacks.spawn(this.spec.id, position),
-      remove: () => this.callbacks.remove(this.id)
+      spawn: (position, characterId) => this.callbacks.spawn(characterId ?? this.spec.id, position),
+      remove: () => this.callbacks.remove(this.id),
+      ...this.callbacks.movePlatform && { movePlatform: this.callbacks.movePlatform }
     });
     this.installPointerHandlers();
   }
@@ -1031,44 +1694,20 @@ var Mascot = class {
   lastPointer;
   activePlatformElement;
   platforms = [];
+  accumulatedMs = 0;
+  frameDuration;
+  random;
+  forceInitialFall;
   /** Advances behavior, animation, physics, and rendering by one clock tick. */
   tick(deltaMs, bounds, platforms = []) {
     if (this.destroyed) return;
     this.platforms = platforms;
-    const environment = this.createEnvironment(bounds, platforms);
-    if (this.state.dragging) {
-      this.dom.render(this.domHandle, this.spec, this.state);
-      return;
-    }
     try {
-      for (let guard = 0; guard < 8; guard += 1) {
-        if (!this.currentBehavior) {
-          this.currentBehavior = this.behavior.selectInitial(environment, this.state.behaviorName);
-          let started = this.startBehavior(environment);
-          if (!started) {
-            this.currentBehavior = this.findFallBehavior();
-            started = this.startBehavior(environment);
-          }
-          if (!started) break;
-        }
-        const activeIE = environment.mascot.environment.activeIE;
-        const wasOnPlatformTop = activeIE.visible && activeIE.topBorder.isOn(this.state);
-        const completed = this.actions.tick(deltaMs, environment, bounds);
-        const remainedNearPlatform = this.state.x >= activeIE.left - PLATFORM_EDGE_TOLERANCE && this.state.x <= activeIE.right + PLATFORM_EDGE_TOLERANCE;
-        if (wasOnPlatformTop && !remainedNearPlatform && !platforms.some((platform) => isOnTop(this.state, platform))) {
-          this.actions.cancel();
-          this.currentBehavior = this.findFallBehavior();
-          if (this.currentBehavior) this.startBehavior(this.createEnvironment(bounds, platforms));
-          break;
-        }
-        if (!completed) break;
-        if (this.destroyed) return;
-        this.currentBehavior = this.behavior.selectNext(this.createEnvironment(bounds, platforms));
-        if (!this.currentBehavior || !this.startBehavior(this.createEnvironment(bounds, platforms))) {
-          this.currentBehavior = this.findFallBehavior();
-          if (!this.currentBehavior || !this.startBehavior(this.createEnvironment(bounds, platforms))) break;
-        }
-        deltaMs = 0;
+      this.ensureBehavior(bounds, platforms, true);
+      this.accumulatedMs += Math.max(0, deltaMs);
+      while (this.accumulatedMs >= this.frameDuration && !this.destroyed) {
+        this.accumulatedMs -= this.frameDuration;
+        this.legacyTick(bounds, platforms);
       }
     } catch (error) {
       this.callbacks.error(error instanceof Error ? error : new Error(String(error)));
@@ -1089,14 +1728,68 @@ var Mascot = class {
     for (const dispose of this.disposers.splice(0)) dispose();
     this.dom.removeMascot(this.domHandle);
   }
-  startBehavior(environment) {
+  startBehavior(environment, bounds, platforms) {
     if (!this.currentBehavior) return false;
     this.state.behaviorName = this.currentBehavior.name;
-    return this.actions.start(this.currentBehavior.name, environment);
+    return this.actions.start(this.currentBehavior.actionName ?? this.currentBehavior.name, environment, false, bounds, platforms);
+  }
+  ensureBehavior(bounds, platforms, initial) {
+    for (let guard = 0; guard < 32 && !this.destroyed; guard += 1) {
+      const environment = this.createEnvironment(bounds, platforms);
+      if (!this.currentBehavior) {
+        this.currentBehavior = initial ? this.forceInitialFall ? this.findFallBehavior() ?? this.behavior.selectInitial(environment) : this.behavior.selectInitial(environment, this.state.behaviorName) : this.selectNextBehavior(environment, bounds);
+        initial = false;
+        if (!this.currentBehavior) this.currentBehavior = this.findFallBehavior();
+        if (!this.currentBehavior || !this.startBehavior(environment, bounds, platforms)) return;
+      }
+      if (this.actions.hasNext(environment, bounds, platforms)) return;
+      this.currentBehavior = this.selectNextBehavior(environment, bounds) ?? this.findFallBehavior();
+      if (!this.currentBehavior) return;
+      if (!this.startBehavior(this.createEnvironment(bounds, platforms), bounds, platforms)) return;
+    }
+  }
+  legacyTick(bounds, platforms) {
+    this.ensureBehavior(bounds, platforms, false);
+    if (!this.currentBehavior) return;
+    const result = this.actions.step(this.createEnvironment(bounds, platforms), bounds, platforms);
+    if (this.destroyed) return;
+    if (result === "lost-ground") {
+      this.state.dragging = false;
+      this.actions.cancel();
+      this.currentBehavior = this.findFallBehavior();
+      if (this.currentBehavior) this.startBehavior(this.createEnvironment(bounds, platforms), bounds, platforms);
+    } else if (result === "complete") {
+      this.currentBehavior = this.selectNextBehavior(this.createEnvironment(bounds, platforms), bounds);
+      if (this.currentBehavior) this.startBehavior(this.createEnvironment(bounds, platforms), bounds, platforms);
+      this.ensureBehavior(bounds, platforms, false);
+    } else if (this.isOutsideVisibleBounds(bounds)) {
+      this.state.x = Math.trunc(bounds.x + this.random() * bounds.width);
+      this.state.y = bounds.y - 256;
+      this.actions.cancel();
+      this.currentBehavior = this.findFallBehavior();
+      if (this.currentBehavior) this.startBehavior(this.createEnvironment(bounds, platforms), bounds, platforms);
+    }
+  }
+  isOutsideVisibleBounds(bounds) {
+    const sprite = this.spec.sprites[this.state.sprite];
+    const width = typeof sprite === "object" && "width" in sprite && sprite.width !== void 0 ? sprite.width : 128;
+    const height = typeof sprite === "object" && "height" in sprite && sprite.height !== void 0 ? sprite.height : 128;
+    const anchorX = this.state.lookRight ? width - this.state.anchorX : this.state.anchorX;
+    const left = this.state.x - anchorX;
+    const top = this.state.y - this.state.anchorY;
+    return left + width <= bounds.x || bounds.x + bounds.width <= left || bounds.y + bounds.height <= top;
   }
   findFallBehavior() {
     return this.behavior.force("Fall") ?? this.behavior.force("\u843D\u4E0B\u3059\u308B");
   }
+  selectNextBehavior(environment, bounds) {
+    const selected = this.behavior.selectNext(environment);
+    if (this.behavior.usedFallback()) {
+      this.state.x = Math.trunc(bounds.x + this.random() * bounds.width);
+      this.state.y = bounds.y - 256;
+    }
+    return selected;
+  }
   createEnvironment(bounds, platforms = this.platforms) {
     const workArea = environmentRectangle(bounds);
     const inactive = environmentRectangle({ x: -100, y: -100, width: 0, height: 0 });
@@ -1111,10 +1804,10 @@ var Mascot = class {
         lookRight: this.state.lookRight,
         environment: {
           cursor: this.callbacks.pointer(),
-          screen: { width: window.innerWidth, height: window.innerHeight },
+          screen: workArea,
           workArea,
-          floor: workArea.bottomBorder,
-          ceiling: workArea.topBorder,
+          floor: edge((point) => isOnFloor(point, bounds, platforms)),
+          ceiling: edge((point) => isOnTop(point, bounds) || platforms.some((candidate) => isOnBottom(point, candidate))),
           activeIE
         }
       }
@@ -1141,6 +1834,7 @@ var Mascot = class {
   }
   installPointerHandlers() {
     const element = this.domHandle.spriteElement;
+    const document2 = element.ownerDocument;
     const listen = (target, type, listener) => {
       target.addEventListener(type, listener);
       this.disposers.push(() => target.removeEventListener(type, listener));
@@ -1149,29 +1843,29 @@ var Mascot = class {
       const pointerEvent = event;
       if (pointerEvent.button !== 0) return;
       event.preventDefault();
-      const point = { x: pointerEvent.clientX, y: pointerEvent.clientY };
+      const point = this.dom.toLocalPoint(pointerEvent.clientX, pointerEvent.clientY);
       this.pointerId = pointerEvent.pointerId;
       this.pointerDown = point;
       this.lastPointer = point;
       this.dragOffset = { x: this.state.x - point.x, y: this.state.y - point.y };
       this.state.dragging = true;
-      this.actions.cancel();
       this.currentBehavior = this.behavior.force("Dragged") ?? this.behavior.force("\u30C9\u30E9\u30C3\u30B0\u3055\u308C\u308B");
-      if (this.currentBehavior) this.state.behaviorName = this.currentBehavior.name;
+      if (this.currentBehavior) this.startBehavior(this.createEnvironment(this.dom.getBounds()), this.dom.getBounds(), this.platforms);
       element.setPointerCapture?.(pointerEvent.pointerId);
     });
-    listen(document, "pointermove", (event) => {
+    listen(document2, "pointermove", (event) => {
       const pointerEvent = event;
       if (!this.state.dragging || pointerEvent.pointerId !== this.pointerId) return;
-      const point = { x: pointerEvent.clientX, y: pointerEvent.clientY };
+      const point = this.dom.toLocalPoint(pointerEvent.clientX, pointerEvent.clientY);
       const previous = this.lastPointer ?? point;
+      const bounds = this.dom.getBounds();
       this.state.vx = (point.x - previous.x) * 0.8;
       this.state.vy = (point.y - previous.y) * 0.8;
       this.state.x = point.x + this.dragOffset.x;
       this.state.y = point.y + this.dragOffset.y;
       this.lastPointer = point;
     });
-    listen(document, "pointerup", (event) => {
+    listen(document2, "pointerup", (event) => {
       const pointerEvent = event;
       if (!this.state.dragging || pointerEvent.pointerId !== this.pointerId) return;
       this.state.dragging = false;
@@ -1179,8 +1873,8 @@ var Mascot = class {
       this.pointerId = void 0;
       this.currentBehavior = this.behavior.force("Thrown") ?? this.behavior.force("\u6295\u3052\u3089\u308C\u308B") ?? this.findFallBehavior();
       if (this.currentBehavior) {
-        this.state.behaviorName = this.currentBehavior.name;
-        this.actions.start(this.currentBehavior.name, this.createEnvironment(this.dom.getBounds()));
+        const bounds = this.dom.getBounds();
+        this.startBehavior(this.createEnvironment(bounds), bounds, this.platforms);
       }
       if (moved < 4) this.callbacks.click(this.snapshot());
     });
@@ -1188,21 +1882,23 @@ var Mascot = class {
 };
 
 // src/platform.ts
-function resolvePlatformElements(source, document2, excludedRoot) {
+function resolvePlatformElements(source, root, excludedRoot) {
   let elements;
   if (typeof source === "string") {
     try {
-      elements = [...document2.querySelectorAll(source)];
+      elements = [...root.querySelectorAll(source)];
     } catch {
       return [];
     }
   } else {
     elements = source;
   }
+  const document2 = root.nodeType === 9 ? root : root.ownerDocument;
+  if (!document2) return [];
   const HTMLElementConstructor = document2.defaultView?.HTMLElement;
   if (!HTMLElementConstructor) return [];
   return [...new Set(elements)].filter(
-    (element) => element instanceof HTMLElementConstructor && element.isConnected && (!excludedRoot || !excludedRoot.contains(element))
+    (element) => element instanceof HTMLElementConstructor && element.isConnected && root.contains(element) && (!excludedRoot || !excludedRoot.contains(element))
   );
 }
 function readPlatformRectangles(elements, workAreaRectangle) {
@@ -1330,21 +2026,26 @@ var ShimejiEngine = class {
   destroyed = false;
   initialized = false;
   platformSource;
-  /** Starts the clock and global listeners. Calling this method more than once is harmless. */
+  additionalPlatformElements = [];
+  movedPlatforms = /* @__PURE__ */ new Map();
+  platformRectangles = /* @__PURE__ */ new Map();
+  /** Starts the clock and container-aware listeners. Calling this method more than once is harmless. */
   initialize() {
     this.assertAlive();
     if (this.initialized) return;
     this.initialized = true;
-    this.listen(document, "pointermove", (event) => {
+    const document2 = this.container.ownerDocument;
+    const view = document2.defaultView;
+    if (!view) throw new Error("ShimejiEngine requires a container connected to a window");
+    this.listen(document2, "pointermove", (event) => {
       const pointerEvent = event;
-      const x = pointerEvent.clientX;
-      const y = pointerEvent.clientY;
+      const { x, y } = this.dom.toLocalPoint(pointerEvent.clientX, pointerEvent.clientY);
       this.pointer = { x, y, dx: x - this.pointer.x, dy: y - this.pointer.y };
     });
-    this.listen(window, "resize", () => this.renderAll());
-    const maintenance = window.setInterval(() => this.dom.ensureMounted(), 2e3);
+    this.listen(view, "resize", () => this.renderAll());
+    const maintenance = view.setInterval(() => this.dom.ensureMounted(), 2e3);
     this.intervals.add(maintenance);
-    this.animationFrame = requestAnimationFrame(this.onAnimationFrame);
+    this.animationFrame = view.requestAnimationFrame(this.onAnimationFrame);
   }
   /** Registers or replaces a parsed or legacy character specification. */
   registerCharacter(spec) {
@@ -1372,10 +2073,14 @@ var ShimejiEngine = class {
     if (!spec) throw new Error(`Character '${characterId}' is not registered`);
     const { bounds, platforms } = this.readFrameGeometry();
     const random = this.options.random ?? Math.random;
+    const randomX = Math.trunc(bounds.x + random() * bounds.width);
+    const spawnInset = Math.min(2, bounds.width / 2);
     const spawnOptions = {
       ...position,
-      x: position.x ?? bounds.x + random() * bounds.width,
-      y: position.y ?? bounds.y
+      // Fall treats the wall in the facing direction as ground. Keep implicit
+      // spawns clear of both side-wall tolerances so even random() === 0 falls.
+      x: position.x ?? Math.min(Math.max(randomX, bounds.x + spawnInset), bounds.x + bounds.width - spawnInset),
+      y: position.y ?? bounds.y + 2
     };
     const id = `shimeji-${this.nextMascotId++}`;
     const mascot = new Mascot(id, spec, this.dom, this.options, spawnOptions, {
@@ -1387,6 +2092,7 @@ var ShimejiEngine = class {
       remove: (mascotId) => {
         if (!this.destroyed) this.remove(mascotId);
       },
+      movePlatform: (element, point) => this.movePlatform(element, point),
       click: (state2) => this.events.emit("click", state2),
       error: (error) => this.events.emit("error", error)
     });
@@ -1423,22 +2129,27 @@ var ShimejiEngine = class {
     this.assertAlive();
     return this.events.on(event, listener);
   }
-  /** Replaces the DOM elements (or selector) exposed to mascots as platforms. */
-  setPlatforms(platforms) {
+  /** Replaces the primary platform source and any additional registered elements. */
+  setPlatforms(platforms, additionalPlatforms = []) {
     this.assertAlive();
     this.platformSource = platforms;
+    this.additionalPlatformElements = additionalPlatforms;
   }
   /** Stops animation and timers, removes listeners and DOM, and revokes all object URLs. */
   destroy() {
     if (this.destroyed) return;
     for (const mascot of this.mascots.values()) mascot.destroy();
     this.mascots.clear();
-    if (this.animationFrame !== void 0) cancelAnimationFrame(this.animationFrame);
+    const view = this.container.ownerDocument.defaultView;
+    if (this.animationFrame !== void 0) view?.cancelAnimationFrame(this.animationFrame);
     this.animationFrame = void 0;
-    for (const interval of this.intervals) window.clearInterval(interval);
+    for (const interval of this.intervals) view?.clearInterval(interval);
     this.intervals.clear();
     for (const dispose of this.disposers.splice(0)) dispose();
     this.dom.destroy();
+    for (const [element, movement] of this.movedPlatforms) element.style.transform = movement.originalTransform;
+    this.movedPlatforms.clear();
+    this.platformRectangles.clear();
     this.sprites.destroy();
     this.specs.clear();
     this.events.clear();
@@ -1457,7 +2168,7 @@ var ShimejiEngine = class {
     const { bounds, platforms } = this.readFrameGeometry();
     for (const mascot of [...this.mascots.values()]) mascot.tick(delta, bounds, platforms);
     this.emitState();
-    this.animationFrame = requestAnimationFrame(this.onAnimationFrame);
+    this.animationFrame = this.container.ownerDocument.defaultView?.requestAnimationFrame(this.onAnimationFrame);
   };
   renderAll() {
     const { bounds, platforms } = this.readFrameGeometry();
@@ -1465,8 +2176,26 @@ var ShimejiEngine = class {
   }
   readFrameGeometry() {
     const bounds = this.dom.getBounds();
-    const elements = resolvePlatformElements(this.platformSource, this.container.ownerDocument).filter((element) => !this.dom.owns(element));
-    return { bounds, platforms: readPlatformRectangles(elements, { left: 0, top: 0 }) };
+    const elements = [.../* @__PURE__ */ new Set([
+      ...resolvePlatformElements(this.platformSource, this.container),
+      ...resolvePlatformElements(this.additionalPlatformElements, this.container)
+    ])].filter((element) => !this.dom.owns(element));
+    const platforms = readPlatformRectangles(elements, this.container.getBoundingClientRect());
+    this.platformRectangles.clear();
+    for (const platform of platforms) this.platformRectangles.set(platform.element, platform);
+    return { bounds, platforms };
+  }
+  movePlatform(element, point) {
+    const rectangle = this.platformRectangles.get(element);
+    if (!rectangle) return;
+    const movement = this.movedPlatforms.get(element) ?? { originalTransform: element.style.transform, x: 0, y: 0 };
+    movement.x += point.x - rectangle.x;
+    movement.y += point.y - rectangle.y;
+    const translate = `translate(${movement.x}px, ${movement.y}px)`;
+    element.style.transform = movement.originalTransform ? `${movement.originalTransform} ${translate}` : translate;
+    rectangle.x = point.x;
+    rectangle.y = point.y;
+    this.movedPlatforms.set(element, movement);
   }
   emitState() {
     this.events.emit("statechange", this.getState());