npm - castle-web-cli - Versions diffs - 0.4.120 → 0.4.121 - Mend

castle-web-cli 0.4.120 → 0.4.121

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 (28) hide show

package/dist/ide.d.ts +1 -0
package/dist/ide.js +44 -0
package/dist/init.js +1 -1
package/dist/shell/assets/{index-Cxmq9Sed.js → index-UEwjXWKI.js} +58 -58
package/dist/shell/index.html +1 -1
package/kits/physics-2d/CLAUDE.md +56 -5
package/kits/physics-2d/behaviors/AnalogStick.jsx +40 -9
package/kits/physics-2d/behaviors/Collider.jsx +12 -0
package/kits/physics-2d/behaviors/Draggable.jsx +67 -23
package/kits/physics-2d/behaviors/Goal.jsx +2 -0
package/kits/physics-2d/behaviors/Joints.jsx +5 -0
package/kits/physics-2d/behaviors/RigidBody.jsx +16 -0
package/kits/physics-2d/behaviors/Slingshot.jsx +48 -16
package/kits/physics-2d/behaviors/Sound.jsx +11 -0
package/kits/physics-2d/behaviors/Sprite.jsx +7 -0
package/kits/physics-2d/behaviors/Tone.jsx +12 -0
package/kits/physics-2d/behaviors/Video.jsx +6 -0
package/kits/physics-2d/castle.json +1 -1
package/kits/physics-2d/editors/SceneEditor.jsx +42 -6
package/kits/physics-2d/engine/ScenePlayer.jsx +9 -3
package/kits/physics-2d/engine/autoInspector.jsx +28 -3
package/kits/physics-2d/engine/physics/PhysicsSystem.js +117 -0
package/kits/physics-2d/engine/physics/controls.js +43 -19
package/kits/physics-2d/engine/propertyRanges.js +27 -0
package/kits/physics-2d/engine/scene.js +86 -4
package/kits/physics-2d/engine/ui.jsx +14 -1
package/kits/physics-2d/package-lock.json +1 -1
package/package.json +2 -1

package/dist/shell/index.html CHANGED Viewed

@@ -10,7 +10,7 @@
     <link rel="icon" type="image/png" sizes="32x32" href="/__castle/ide/favicon-32x32.png" />
     <link rel="icon" type="image/png" sizes="16x16" href="/__castle/ide/favicon-16x16.png" />
     <link rel="icon" href="/__castle/ide/favicon.ico" sizes="any" />
-    <script type="module" crossorigin src="/__castle/ide/assets/index-Cxmq9Sed.js"></script>
+    <script type="module" crossorigin src="/__castle/ide/assets/index-UEwjXWKI.js"></script>
     <link rel="stylesheet" crossorigin href="/__castle/ide/assets/index-BkJ87APM.css">
   </head>
   <body>

package/kits/physics-2d/CLAUDE.md CHANGED Viewed

@@ -72,7 +72,21 @@ A behavior is a class. Minimal contract:
 // behaviors/MyThing.jsx
 export class MyThing {
   static behaviorName = 'MyThing'; // must match the key used in .scene
-  static defaultProps = { speed: 200 };
+  static defaultProps = { speed: 200, power: 0.5 };
+  // Optional. Inspector ranges for numeric props. Without one, a number field is
+  // an unbounded scrubber stepping by 1 — wrong for anything living in 0..1.
+  // Giving BOTH min and max makes it a real slider. A `max` also caps typed
+  // entry, so only set one where going past it is meaningless.
+  static propertyMeta = {
+    power: { min: 0, max: 1, step: 0.05 },
+  };
+  // Optional. Other components this one needs BESIDE IT on the same actor.
+  // Adding this behavior in the editor adds any that are missing. It does NOT
+  // fix a blueprint you write by hand — so when you author a blueprint, include
+  // the siblings yourself.
+  static expectedSiblings = ['Collider'];
   constructor(props) {
     this.props = props;
@@ -231,6 +245,11 @@ In a behavior's `update`, steer bodies through `scene.physics` (never write
 - `scene.physics.applyForce(actor, { x, y })` — add a matter-space force.
 - `scene.physics.getVelocity(actor)` — current velocity `{ x, y }`.
 - `scene.physics.isColliding(a, b)` — are these two actors touching right now?
+- `scene.physics.actorAtPoint(x, y)` — topmost actor whose **collider** contains
+  the point, or null. Shape-accurate and rotation-aware, so it's what a tap test
+  should use. (`scene.actorAt` tests the rectangular Layout box instead, which is
+  looser — it's what the editor uses for click-to-select.)
+- `scene.physics.containsPoint(actor, x, y)` — the same test for one actor.
 ### Collision callbacks
@@ -254,13 +273,37 @@ export class Coin {
 ### Built-in controls (add these behaviors, no code needed)
 These read input and drive the actor through the physics system, so the actor
-still collides with the world. Each needs a `RigidBody` (dynamic) + `Collider`.
+still collides with the world. Each needs a `RigidBody` (dynamic) + `Collider` --
+**not optional**: no Collider means no physics body at all, and the control is
+silently inert. The editor adds them for you (`expectedSiblings`), but a
+blueprint you write by hand must include them itself.
 Controls are **touch/pointer-first** (Castle games are played on mobile first;
 touch degrades to mouse). Keyboard, if added, should only *duplicate* an
 on-screen control -- never be the only way to play.
-- **`Draggable`** — grab the actor with the pointer and fling it (springy,
-  collides). `stiffness`.
+- **`Draggable`** — grab the actor with the pointer and fling it (collides).
+  `stiffness`.
+  - **The touch zone is the `Collider`, at its live orientation** — not the
+    Layout box. A circle is round to the touch, and a rotated actor's grabbable
+    area rotates with it. An actor whose collider is smaller than its Layout box
+    (which `mode: 'auto'` produces, since it shrink-wraps the sprite's opaque
+    pixels) is grabbable only where the collider is.
+  - **The hold is at the point you touched**, so grabbing off-center turns the
+    object as well as moving it — grab a plank by one end and it swings.
+  - **A drag belongs to the finger that started it.** Later fingers can't steal
+    or drop it, and a second finger can drag a second actor at the same time.
+  - `stiffness` is `0` (loose, swingy) to `1` (rigid, snaps to the pointer),
+    default `0.3`. It's mapped onto matter's very compressed useful band, so the
+    low end is genuinely floppy — reach for `0.1`–`0.3` for a rag-doll feel and
+    `0.7`+ for a tight one.
+**All three controls are per-finger**, and each claims the pointer it started on,
+so they coexist: a player can work an `AnalogStick` with one thumb while dragging
+with the other, and two `Draggable` actors can be dragged at once. A press that
+lands on a control's own collider outranks one that merely takes any press, so a
+`Slingshot` set to `grabAnywhere` never steals a finger that grabbed a
+`Draggable`. Custom controls get the same treatment via `scene.claimPointer` —
+see the SceneRuntime API below.
 - **`Slingshot`** — press the actor, pull back, release to launch it the
   opposite way (angry-birds), with an aim arrow. `speed`, `maxDrag`.
 - **`AnalogStick`** — on-screen virtual joystick (press anywhere) that drives
@@ -366,6 +409,12 @@ draw(actor, scene, ctx) {
   directly is only for `static`/`kinematic` bodies.
 - **Editor vs play.** Physics only steps during play; in the editor actors sit
   where you place them. `RigidBody.velocityX/Y` apply once when play starts.
+- **No `Collider` means no physics at all.** A body only exists for an actor with
+  a Collider, so `RigidBody`, `Draggable`, `Slingshot`, `AnalogStick`, `Joints`
+  and collision callbacks are all silently inert without one — nothing errors,
+  the actor just sits there. The editor's add-behavior button pulls the missing
+  pieces in, but a blueprint you write yourself gets no such help: if it has any
+  of those, give it a `Collider` too.
 - **A joint binds only when both actors have a body.** If a `Joints` entry's
   owner or `target` has no `Collider` (or the target id is wrong/missing), that
   link is silently skipped until both bodies exist. `weld`/`pin` want the two
@@ -431,7 +480,9 @@ To generate path art, emit an svg of **shapes** rather than per-pixel rects and
 - `scene.time` — seconds since start.
 - `scene.keys` — `Set` of currently-held KeyboardEvent codes (e.g. `'ArrowLeft'`, `'KeyA'`, `'Space'`). Read in `update`.
-- `scene.pointer` — `{ x, y, down }` in world (card) coordinates, camera-adjusted.
+- `scene.pointer` — `{ x, y, down }` in world (card) coordinates, camera-adjusted. The **primary** pointer: the one held longest. Use this for anything single-touch.
+- `scene.pointers` — `Map` of every active pointer (finger / mouse / stylus) by id, each `{ id, x, y, down, justPressed, claimedBy }`, same coordinates. For multi-touch: latch the `id` a gesture began on and follow that entry, so another finger landing can't hijack it. `justPressed` is that pointer's press edge for this frame (a shared `down` flag would miss a finger landing while another is already held). Entries disappear on release.
+- `scene.claimPointer(id, ownerId, priority?)` / `scene.ownsPointer(id, ownerId)` — take a finger for one gesture so two controls can't both act on it, and check you still hold it. A higher `priority` takes it from a lower one, which is how a control that was actually pressed (a `Draggable`'s collider) beats one that takes any press (an `AnalogStick`), regardless of actor order. Claims vanish with the pointer, so there's nothing to release. This is what lets a player work a stick with one thumb and drag with the other.
 - `scene.getActor(id)` / `scene.getActors()` (sorted by Layout.z) / `scene.getComponent(actor, name)`.
 - `scene.actorWith('GameController')` / `scene.actorsWith('Brick')` — find one / all actors carrying a given behavior. Prefer these to `getActors().find(a => a.components.X)`.
 - `scene.colliderRect(actorOrId)` — rect from Layout + Collider, or null.

package/kits/physics-2d/behaviors/AnalogStick.jsx CHANGED Viewed

@@ -1,7 +1,13 @@
 import React from 'react';
 import { Panel, SelectField } from '../engine/ui';
 import { AutoFields, overrideProps } from '../engine/autoInspector';
-import { analogVelocity, inActorWorldSpace, pressOnDraggable, stickVector } from '../engine/physics/controls';
+import {
+  GREEDY_CLAIM,
+  acquirePress,
+  analogVelocity,
+  inActorWorldSpace,
+  stickVector,
+} from '../engine/physics/controls';
 // AnalogStick: an on-screen virtual joystick that drives the actor it's on --
 // the look and feel of castle-client's Analog Stick. Press anywhere to place
@@ -13,6 +19,8 @@ import { analogVelocity, inActorWorldSpace, pressOnDraggable, stickVector } from
 //   axes      -> restrict to 'horizontal' / 'vertical' / 'both'.
 export class AnalogStick {
   static behaviorName = 'AnalogStick';
+  // Drives a body, so it needs one: Collider + dynamic RigidBody.
+  static expectedSiblings = ['Collider', 'RigidBody'];
   static defaultProps = {
     speed: 6,
@@ -20,27 +28,49 @@ export class AnalogStick {
     axes: 'both',
   };
+  // `maxRadius` is the stick's travel in px; below ~10 the knob has no usable
+  // throw and the control reads as broken.
+  static propertyMeta = {
+    speed: { min: 0, step: 0.5 },
+    maxRadius: { min: 10, step: 5 },
+  };
   constructor(props) {
     this.props = props;
   }
-  update(actor, scene) {
-    const p = scene.pointer;
+  // The finger this stick is following, placing it on a fresh press if it isn't
+  // following one yet. The stick stays with the finger that placed it, so a
+  // second finger elsewhere (another stick, a drag) never yanks it -- and it
+  // gives the pointer up if a targeted control outranks its claim.
+  trackedPointer(actor, scene) {
     const rt = actor.runtime;
-    const pressed = p.down && !rt._stickWasDown;
-    rt._stickWasDown = p.down;
-    // A press on a draggable is consumed by the drag; every other press drives
-    // the stick.
-    if (pressed && !pressOnDraggable(scene)) rt._stickOrigin = { x: p.x, y: p.y };
+    if (rt._stickPointerId != null && scene.ownsPointer(rt._stickPointerId, actor.id)) {
+      const held = scene.pointers.get(rt._stickPointerId);
+      if (held?.down) return held;
+    }
+    rt._stickPointerId = null;
+    // Any fresh press will do -- the stick is placed wherever you touch -- but
+    // only one nobody more specific wants.
+    const press = acquirePress(scene, actor.id, () => GREEDY_CLAIM);
+    if (!press) return null;
+    rt._stickPointerId = press.id;
+    rt._stickOrigin = { x: press.x, y: press.y };
+    return press;
+  }
+  update(actor, scene) {
+    const rt = actor.runtime;
+    const p = this.trackedPointer(actor, scene);
     // Only drive velocity while the stick is actually held.
-    if (p.down && rt._stickOrigin) {
+    if (p?.down && rt._stickOrigin) {
       rt._stickKnob = stickVector(p, rt._stickOrigin, this.props.maxRadius ?? 60);
       scene.physics.setVelocity(actor, analogVelocity(p, rt._stickOrigin, this.props));
       rt._stickActive = true;
       return;
     }
+    rt._stickPointerId = null;
     rt._stickOrigin = null;
     rt._stickKnob = null;
     // Stop ONCE on release, and only on the driven axes (so a top-down mover
@@ -92,6 +122,7 @@ export class AnalogStick {
         />
         <AutoFields
           defaultProps={AnalogStick.defaultProps}
+          meta={AnalogStick.propertyMeta}
           component={component}
           setComponent={setComponent}
           exclude={['axes']}

package/kits/physics-2d/behaviors/Collider.jsx CHANGED Viewed

@@ -1,6 +1,7 @@
 import React, { useEffect, useState } from 'react';
 import { NumberField, Panel, SelectField } from '../engine/ui';
 import { AutoFields } from '../engine/autoInspector';
+import { POSITIVE } from '../engine/propertyRanges';
 import { computeAutoFit, getColliderRect, getColliderShapes, intersects } from '../engine/collider';
 // --- inspector styles ------------------------------------------------------
@@ -99,6 +100,16 @@ export class Collider {
     density: 0.001,
   };
+  // Inspector ranges. No `max` on any of these: matter treats them as open-ended
+  // (bounciness "can exceed 1" per the docs, and stiction above 1 is meaningful),
+  // and a max is a hard authoring ceiling here -- typed entry is clamped to it,
+  // not just the slider. `min: 0` and a fine step are the parts that are safe.
+  static propertyMeta = {
+    bounciness: POSITIVE,
+    friction: POSITIVE,
+    frictionStatic: POSITIVE,
+  };
   constructor(props) {
     this.props = props;
   }
@@ -276,6 +287,7 @@ export class Collider {
         <NumberField label="Density" value={density} onChange={(v) => setComponent({ density: v })} />
         <AutoFields
           defaultProps={Collider.defaultProps}
+          meta={Collider.propertyMeta}
           component={component}
           setComponent={setComponent}
           exclude={['density']}

package/kits/physics-2d/behaviors/Draggable.jsx CHANGED Viewed

@@ -1,20 +1,40 @@
 import React from 'react';
 import { Panel } from '../engine/ui';
 import { AutoFields } from '../engine/autoInspector';
-import { centerOf, chaseVelocity, inActorWorldSpace } from '../engine/physics/controls';
+import { UNIT } from '../engine/propertyRanges';
+import { TARGETED_CLAIM, dragHold, inActorWorldSpace } from '../engine/physics/controls';
-// Draggable: grab the actor with the pointer and fling it around. Chases the
-// pointer with a springy velocity (via the physics system) so it still collides
-// with the world -- the same feel as castle-client's Drag. Grabs the topmost
-// actor under the press (uses scene.actorAt), and keeps dragging until release
-// even if the pointer slips off. Needs a RigidBody (dynamic) + Collider.
+// Draggable: grab the actor with the pointer and fling it around. The grab is a
+// real physics constraint from the exact spot that was touched to the pointer,
+// so the object still collides with the world AND turns when held off-center --
+// grab a plank by its end and it swings.
 //
-//   stiffness -> how hard it chases the pointer (fraction of the gap per step).
+// The touch zone is the actor's COLLIDER at its current orientation (via
+// scene.physics.actorAtPoint), not its Layout box, so a circle is round and a
+// rotated actor's grabbable area rotates with it.
+//
+// A drag belongs to the finger that started it: it follows that pointer alone
+// until that pointer lifts, so later fingers can't steal or drop it, and a
+// second finger can drag a second actor at the same time.
+//
+//   stiffness -> how tightly the object is held, 0 (loose and swingy) to 1
+//   (rigid, snaps to the pointer). Mapped through `dragHold`, which spreads the
+//   authored range over matter's very compressed useful band and eases damping
+//   along with it, so the low end is genuinely floppy rather than just slow.
 export class Draggable {
   static behaviorName = 'Draggable';
+  // Inert without a body to hold: needs a Collider (to have one at all) and a
+  // dynamic RigidBody (so the grab can actually move it).
+  static expectedSiblings = ['Collider', 'RigidBody'];
   static defaultProps = {
-    stiffness: 0.1,
+    stiffness: 0.3,
+  };
+  // 0..1 with a fine step, so the inspector renders a real slider over the
+  // whole range rather than an unbounded whole-number scrubber.
+  static propertyMeta = {
+    stiffness: UNIT,
   };
   constructor(props) {
@@ -22,26 +42,49 @@ export class Draggable {
   }
   update(actor, scene) {
-    const p = scene.pointer;
     const rt = actor.runtime;
-    const pressed = p.down && !rt._dragWasDown;
-    rt._dragWasDown = p.down;
-    if (pressed && scene.actorAt(p.x, p.y)?.id === actor.id) rt._dragging = true;
-    if (!p.down) rt._dragging = false;
-    if (!rt._dragging) return;
+    const held = rt._dragPointerId == null ? null : scene.pointers.get(rt._dragPointerId);
+    // The finger that started this drag lifted (or its contact was cancelled).
+    if (rt._dragPointerId != null && !held?.down) {
+      scene.physics.release(actor);
+      rt._dragPointerId = null;
+      return;
+    }
+    if (held) return scene.physics.moveGrab(actor, held.x, held.y);
-    scene.physics.setVelocity(actor, chaseVelocity(p, actor.components.Layout, this.props));
+    // Idle: look for a new press on this actor. Each pointer carries its own
+    // press edge, so a finger landing while another is already down still
+    // registers -- and an actor already being dragged never gets here, so the
+    // first finger keeps it.
+    for (const p of scene.pointers.values()) {
+      if (!p.justPressed) continue;
+      if (scene.physics.actorAtPoint(p.x, p.y)?.id !== actor.id) continue;
+      // A press on this collider is unambiguous, so it outranks any control that
+      // merely takes presses anywhere -- whatever order the actors update in.
+      if (!scene.claimPointer(p.id, actor.id, TARGETED_CLAIM)) continue;
+      if (scene.physics.grab(actor, p.x, p.y, dragHold(this.props.stiffness))) {
+        rt._dragPointerId = p.id;
+      }
+      return;
+    }
   }
-  // Feedback while held (castle-client's Drag overlay): a circle on the grabbed
-  // object + a circle at the touch, connected by a line -- both translucent white
-  // with a solid white border. Drawn in world space so it doesn't spin with the
-  // actor.
+  // Feedback while held (castle-client's Drag overlay): a circle where the
+  // object is actually being held + a circle at the touch, connected by a line
+  // -- both translucent white with a solid white border. The handle comes from
+  // the constraint the simulation is solving, so it sits exactly where the
+  // physics holds the object and tracks it through rotation. Drawn in world
+  // space so the overlay itself doesn't spin with the actor.
   draw(actor, scene, ctx) {
-    if (!actor.runtime._dragging) return;
-    const handle = centerOf(actor.components.Layout);
-    const touch = { x: scene.pointer.x, y: scene.pointer.y };
-    inActorWorldSpace(ctx, actor.components.Layout, (g) => drawDrag(g, handle, touch));
+    const id = actor.runtime._dragPointerId;
+    if (id == null) return;
+    const handle = scene.physics.grabPoint(actor);
+    const touch = scene.pointers.get(id);
+    if (!handle || !touch) return;
+    inActorWorldSpace(ctx, actor.components.Layout, (g) =>
+      drawDrag(g, handle, { x: touch.x, y: touch.y })
+    );
   }
   static Inspector({ component, setComponent, override }) {
@@ -49,6 +92,7 @@ export class Draggable {
       <Panel title="Draggable" overridden={override?.anyOverridden()}>
         <AutoFields
           defaultProps={Draggable.defaultProps}
+          meta={Draggable.propertyMeta}
           component={component}
           setComponent={setComponent}
           override={override}

package/kits/physics-2d/behaviors/Goal.jsx CHANGED Viewed

@@ -3,6 +3,8 @@
 // `isTrigger: true`. Put it on an actor with a Layout and a trigger Collider.
 export class Goal {
   static behaviorName = 'Goal';
+  // Scores on collision callbacks, which only fire for an actor with a body.
+  static expectedSiblings = ['Collider'];
   static defaultProps = {};

package/kits/physics-2d/behaviors/Joints.jsx CHANGED Viewed

@@ -24,6 +24,11 @@ const ANCHOR_MAX = 120;
 // point every instance at the same actor.
 export class Joints {
   static behaviorName = 'Joints';
+  // A link binds two bodies, so the OWNER needs a Collider to have one. Only the
+  // owner: the `target` actor needs one too, but it isn't a sibling -- it's a
+  // separate actor the author picks later, and inventing a Collider on it isn't
+  // this hook's business.
+  static expectedSiblings = ['Collider'];
   static defaultProps = { list: [] };

package/kits/physics-2d/behaviors/RigidBody.jsx CHANGED Viewed

@@ -1,6 +1,7 @@
 import React from 'react';
 import { Panel, SelectField } from '../engine/ui';
 import { AutoFields, overrideProps } from '../engine/autoInspector';
+import { DAMPING } from '../engine/propertyRanges';
 // RigidBody makes an actor a physics object. Pair it with a Collider (which
 // gives the shape + material). The simulation reads these props each frame; the
@@ -17,6 +18,9 @@ import { AutoFields, overrideProps } from '../engine/autoInspector';
 //   velocityX/velocityY  -> initial velocity, applied once when play starts.
 export class RigidBody {
   static behaviorName = 'RigidBody';
+  // No Collider means no body at all (matterBridge's `isPhysicsActor`), so a
+  // RigidBody on its own simulates nothing.
+  static expectedSiblings = ['Collider'];
   static defaultProps = {
     bodyType: 'dynamic',
@@ -31,6 +35,17 @@ export class RigidBody {
     angularVelocity: 0,
   };
+  // `drag`/`angularDrag` are matter's air friction, where values above 1 flip
+  // the velocity sign and destabilize the body -- so 1 is a real ceiling, not a
+  // convenience. `gravityScale` deliberately has none: negative is legitimate
+  // (it inverts gravity), as is scaling well past 1.
+  static propertyMeta = {
+    gravityScale: { step: 0.1 },
+    drag: DAMPING,
+    angularDrag: DAMPING,
+    angularVelocity: { step: 0.1 },
+  };
   constructor(props) {
     this.props = props;
   }
@@ -47,6 +62,7 @@ export class RigidBody {
         />
         <AutoFields
           defaultProps={RigidBody.defaultProps}
+          meta={RigidBody.propertyMeta}
           component={component}
           setComponent={setComponent}
           exclude={['bodyType']}

package/kits/physics-2d/behaviors/Slingshot.jsx CHANGED Viewed

@@ -1,7 +1,15 @@
 import React from 'react';
 import { Panel } from '../engine/ui';
 import { AutoFields } from '../engine/autoInspector';
-import { inActorWorldSpace, pressOnDraggable, slingLaunch, slingPull } from '../engine/physics/controls';
+import { PIXELS } from '../engine/propertyRanges';
+import {
+  GREEDY_CLAIM,
+  TARGETED_CLAIM,
+  acquirePress,
+  inActorWorldSpace,
+  slingLaunch,
+  slingPull,
+} from '../engine/physics/controls';
 // Slingshot: pull back and release to fling the actor the opposite way
 // (angry-birds style) -- the physics feel of castle-client's Sling. While
@@ -14,6 +22,8 @@ import { inActorWorldSpace, pressOnDraggable, slingLaunch, slingPull } from '../
 //                   like castle-client); set false to require pressing the actor.
 export class Slingshot {
   static behaviorName = 'Slingshot';
+  // Launches a body, so it needs one: Collider + dynamic RigidBody.
+  static expectedSiblings = ['Collider', 'RigidBody'];
   static defaultProps = {
     speed: 0.08,
@@ -21,31 +31,51 @@ export class Slingshot {
     grabAnywhere: true,
   };
+  // `speed` is a small multiplier (0.08 default), so whole-number steps were
+  // useless here. `maxDrag` is pixels of pull.
+  static propertyMeta = {
+    speed: { min: 0, step: 0.01 },
+    maxDrag: PIXELS,
+  };
   constructor(props) {
     this.props = props;
   }
   update(actor, scene) {
-    const p = scene.pointer;
     const rt = actor.runtime;
-    const pressed = p.down && !rt._slingWasDown;
-    rt._slingWasDown = p.down;
-    // A press on a draggable is consumed by the drag; otherwise the sling grabs
-    // (anywhere, or on its own actor when grabAnywhere is off).
-    const grabAnywhere = this.props.grabAnywhere ?? true;
-    if (
-      pressed &&
-      !pressOnDraggable(scene) &&
-      (grabAnywhere || scene.actorAt(p.x, p.y)?.id === actor.id)
-    ) {
-      rt._slinging = true;
-      // Anchor at the press point (like castle-client): the aim/launch depends
-      // on the drag gesture, not where the press landed relative to the actor.
-      rt._slingAnchor = { x: p.x, y: p.y };
+    if (!rt._slinging) {
+      const grabAnywhere = this.props.grabAnywhere ?? true;
+      const press = acquirePress(scene, actor.id, (p) => {
+        // Collider-accurate, at the body's live orientation -- the same pick
+        // Draggable uses, so the two agree on what "on this actor" means.
+        const onSelf = scene.physics.actorAtPoint(p.x, p.y)?.id === actor.id;
+        if (!grabAnywhere && !onSelf) return null;
+        // Pressing the body itself is an unambiguous aim; taking any press
+        // anywhere is not, so it yields to a control that was actually targeted.
+        return onSelf ? TARGETED_CLAIM : GREEDY_CLAIM;
+      });
+      if (press) {
+        rt._slingPointerId = press.id;
+        rt._slinging = true;
+        // Anchor at the press point (like castle-client): the aim/launch depends
+        // on the drag gesture, not where the press landed relative to the actor.
+        rt._slingAnchor = { x: press.x, y: press.y };
+      }
     }
     if (!rt._slinging) return;
+    const p = scene.pointers.get(rt._slingPointerId);
+    // Outranked mid-aim, or the contact was cancelled: drop the shot rather than
+    // launching from an anchor the player has stopped steering.
+    if (!p || !scene.ownsPointer(rt._slingPointerId, actor.id)) {
+      rt._slinging = false;
+      rt._slingPointerId = null;
+      rt._slingAim = null;
+      return;
+    }
     if (p.down) {
       // Hold still while aiming, and remember the aim point for draw().
       scene.physics.setVelocity(actor, { x: 0, y: 0 });
@@ -53,6 +83,7 @@ export class Slingshot {
     } else {
       scene.physics.setVelocity(actor, slingLaunch(rt._slingAnchor, p, this.props));
       rt._slinging = false;
+      rt._slingPointerId = null;
       rt._slingAim = null;
     }
   }
@@ -79,6 +110,7 @@ export class Slingshot {
       <Panel title="Slingshot" overridden={override?.anyOverridden()}>
         <AutoFields
           defaultProps={Slingshot.defaultProps}
+          meta={Slingshot.propertyMeta}
           component={component}
           setComponent={setComponent}
           override={override}

package/kits/physics-2d/behaviors/Sound.jsx CHANGED Viewed

@@ -4,6 +4,7 @@ import { mediaElement, playMedia, playOneShot, setMediaPan, stopMedia } from '..
 import { mediaFilesOfKind } from '../engine/files';
 import { Panel, SelectField } from '../engine/ui';
 import { AutoFields, overrideProps } from '../engine/autoInspector';
+import { PAN, UNIT } from '../engine/propertyRanges';
 // Plays a sound file (.mp3 / .wav / .m4a) from an actor.
 //
@@ -39,6 +40,15 @@ export class Sound {
     playOnStart: true,
   };
+  // Mirrors the clamps `readSettings` already applies at runtime, so the
+  // inspector can't author a value the sound would silently ignore -- including
+  // playbackRate's 0.01..10, where the classic editor's ceiling lives.
+  static propertyMeta = {
+    volume: UNIT,
+    playbackRate: { min: 0.01, max: 10, step: 0.05 },
+    pan: PAN,
+  };
   constructor(props) {
     this.props = props;
   }
@@ -80,6 +90,7 @@ export class Sound {
         />
         <AutoFields
           defaultProps={Sound.defaultProps}
+          meta={Sound.propertyMeta}
           component={component}
           setComponent={setComponent}
           only={['volume', 'playbackRate', 'pan', 'loop', 'polyphonic', 'playOnStart']}

package/kits/physics-2d/behaviors/Sprite.jsx CHANGED Viewed

@@ -38,6 +38,12 @@ export class Sprite {
     tileSize: 50,
   };
+  // Tile cell size in card units -- a floor of 1 (0 would divide by zero when
+  // laying out the repeat), no ceiling since a deck may tile larger than a card.
+  static propertyMeta = {
+    tileSize: { min: 1, step: 1 },
+  };
   constructor(props) {
     this.props = props;
   }
@@ -173,6 +179,7 @@ export class Sprite {
         />
         <AutoFields
           defaultProps={Sprite.defaultProps}
+          meta={Sprite.propertyMeta}
           component={component}
           setComponent={setComponent}
           only={['playing', 'tint', 'tileSize']}

package/kits/physics-2d/behaviors/Tone.jsx CHANGED Viewed

@@ -2,6 +2,7 @@ import React from 'react';
 import { playTone, WAVEFORMS } from '../engine/tone';
 import { Panel, SelectField } from '../engine/ui';
 import { AutoFields, overrideProps } from '../engine/autoInspector';
+import { PAN, POSITIVE, UNIT } from '../engine/propertyRanges';
 // Plays a synthesized note -- no audio file involved. This is the cheapest sound
 // a deck can make: a blip on a pickup, a thud on a miss, a rising scale as a
@@ -27,6 +28,16 @@ export class Tone {
     playOnStart: false,
   };
+  // `note` is MIDI, which is genuinely 0..127. `attack`/`release` are seconds,
+  // so they get a floor but no ceiling.
+  static propertyMeta = {
+    note: { min: 0, max: 127, step: 1 },
+    attack: POSITIVE,
+    release: POSITIVE,
+    volume: UNIT,
+    pan: PAN,
+  };
   constructor(props) {
     this.props = props;
   }
@@ -54,6 +65,7 @@ export class Tone {
         />
         <AutoFields
           defaultProps={Tone.defaultProps}
+          meta={Tone.propertyMeta}
           component={component}
           setComponent={setComponent}
           only={['note', 'attack', 'release', 'volume', 'pan', 'playOnStart']}

package/kits/physics-2d/behaviors/Video.jsx CHANGED Viewed

@@ -5,6 +5,7 @@ import { mediaFilesOfKind } from '../engine/files';
 import { spriteDestRect } from '../engine/spriteGeometry';
 import { Panel, SelectField } from '../engine/ui';
 import { AutoFields, overrideProps } from '../engine/autoInspector';
+import { UNIT } from '../engine/propertyRanges';
 // Plays a video file (.mp4 / .webm / .mov / .m4v) inside the actor's Layout box.
 //
@@ -29,6 +30,10 @@ export class Video {
     volume: 1,
   };
+  static propertyMeta = {
+    volume: UNIT,
+  };
   constructor(props) {
     this.props = props;
   }
@@ -100,6 +105,7 @@ export class Video {
         />
         <AutoFields
           defaultProps={Video.defaultProps}
+          meta={Video.propertyMeta}
           component={component}
           setComponent={setComponent}
           only={['playing', 'loop', 'muted', 'volume']}

package/kits/physics-2d/castle.json CHANGED Viewed

@@ -123,5 +123,5 @@
   "main": "main.jsx",
   "autoUpdateWhenImported": true,
   "title": "physics-2d",
-  "publishedVersion": "2026-08-12T18:15:12.718Z"
+  "publishedVersion": "2026-08-14T21:20:31.152Z"
 }