npm - @react-shimeji/core - Versions diffs - 0.2.3 → 0.3.1 - Mend

@react-shimeji/core 0.2.3 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/index.js CHANGED Viewed

@@ -1,67 +1,82 @@
 // 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) {
@@ -77,6 +92,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;
+    });
   }
 };
@@ -89,6 +112,9 @@ var actionTypeNames = {
   Animate: "Animate",
   Move: "Move",
   Embedded: "Embedded",
+  Composite: "Sequence",
+  Fixed: "Animate",
+  Pause: "Stay",
   \u8907\u5408: "Sequence",
   \u9078\u629E: "Select",
   \u53C2\u7167: "Reference",
@@ -138,12 +164,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";
@@ -167,20 +194,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")]
@@ -196,18 +229,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"
   };
@@ -313,7 +361,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 = [];
@@ -514,7 +562,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 {
@@ -524,7 +572,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;
@@ -532,8 +580,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)) }));
@@ -555,62 +603,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;
@@ -618,29 +680,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;
@@ -657,251 +736,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);
   }
 };
@@ -930,7 +1590,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);
@@ -959,10 +1618,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();
   }
@@ -984,44 +1647,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)));
@@ -1042,14 +1681,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 });
@@ -1064,10 +1757,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
         }
       }
@@ -1094,6 +1787,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));
@@ -1102,29 +1796,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;
@@ -1132,8 +1826,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());
     });
@@ -1141,21 +1835,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) {
@@ -1283,21 +1979,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) {
@@ -1325,10 +2026,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, {
@@ -1340,6 +2045,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)
     });
@@ -1376,22 +2082,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();
@@ -1410,7 +2121,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();
@@ -1418,8 +2129,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());