@scenoco-three/box2d 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SceNoCo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# @scenoco-three/box2d
+
+**2D physics** for [SceNoCo](https://github.com/) on [planck](https://piqnt.com/planck.js)
+(a pure-JS [Box2D](https://box2d.org) port): a `<Physics2D>` scene setting plus
+`<RigidBody2D>` / `<Collider2D>` components, built entirely on the public `System` seam in
+`@scenoco-three/core`. Import it for 2D physics; don't, and none ships. The 3D counterpart is
+[`@scenoco-three/rapier`](../rapier).
+
+Unlike the Rapier add-on, **no async init** — planck is pure JS, so import and load directly.
+
+```ts
+import '@scenoco-three/box2d'; // registers the tags (side effect)
+engine.loadScene(bundle);       // a scene with <Physics2D>/<RigidBody2D>/<Collider2D>
+```
+
+```xml
+<Scene>
+  <Physics2D gravity="0 -9.81" />
+  <Mesh id="ball" position="0 6 0">
+    <SphereGeometry radius="0.3" />
+    <Components>
+      <RigidBody2D bullet="true" />          <!-- continuous collision for a fast ball -->
+      <Collider2D restitution="0.9" />        <!-- bouncy circle, auto-sized from the geometry -->
+    </Components>
+  </Mesh>
+  <Mesh id="paddle" position="0 0.5 0">
+    <BoxGeometry width="3" height="0.4" depth="0.5" />
+    <Components>
+      <RigidBody2D kind="kinematic" />        <!-- you move the node; the body follows -->
+      <Collider2D shape="box" halfExtents="1.5 0.2" />
+    </Components>
+  </Mesh>
+</Scene>
+```
+
+The simulation runs in the **XY plane**: a body's position drives the node's `x`/`y`, its
+angle drives `rotation.z`. Contacts are delivered to components via duck-typed, **Unity-style
+hooks** — implement any of:
+
+```ts
+onCollisionEnter2D(other: Object3D): void   // solid touch began
+onCollisionExit2D(other: Object3D): void
+onTriggerEnter2D(other: Object3D): void     // sensor (isSensor) overlap began
+onTriggerExit2D(other: Object3D): void
+```
+
+Contacts are queued during the step and dispatched after it, so a hook may safely destroy a
+brick (or any scene object) without corrupting the in-progress simulation.
+
+`three` is a peer dependency. See the [repository](../../README.md) and
+[ARCHITECTURE.md](../../ARCHITECTURE.md) (`System` seam).
+
+## License
+
+[MIT](./LICENSE)

package/dist/Collider2D.d.ts

@@ -0,0 +1,26 @@
+import { type FixtureOpt, type Shape } from 'planck';
+import { Component } from '@scenoco-three/core';
+/**
+ * A 2D collision shape on the node. The `Physics2DSystem` attaches it to the
+ * node's `<RigidBody2D>` when it builds that body (no manual registration).
+ *
+ * `shape="auto"` reads the host mesh's geometry: a `<BoxGeometry>` becomes a box
+ * (XY half-extents from width/height), a `<SphereGeometry>` a circle. Set
+ * `isSensor="true"` for a trigger — it reports overlaps (`onTriggerEnter2D`) but
+ * generates no collision response.
+ */
+export declare class Collider2D extends Component {
+    shape: string;
+    halfExtents: number[];
+    radius: number;
+    density: number;
+    friction: number;
+    restitution: number;
+    isSensor: boolean;
+    /** The planck shape for this collider, resolving `auto` from the host geometry. */
+    toShape(): Shape;
+    /** Fixture material/flags for `body.createFixture(shape, opt)`. */
+    fixtureOpt(): FixtureOpt;
+    /** Derive a shape from the host mesh's geometry parameters. */
+    private autoShape;
+}

package/dist/Collider2D.js

@@ -0,0 +1,89 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BoxShape, CircleShape } from 'planck';
+import { Component, component, property } from '@scenoco-three/core';
+/**
+ * A 2D collision shape on the node. The `Physics2DSystem` attaches it to the
+ * node's `<RigidBody2D>` when it builds that body (no manual registration).
+ *
+ * `shape="auto"` reads the host mesh's geometry: a `<BoxGeometry>` becomes a box
+ * (XY half-extents from width/height), a `<SphereGeometry>` a circle. Set
+ * `isSensor="true"` for a trigger — it reports overlaps (`onTriggerEnter2D`) but
+ * generates no collision response.
+ */
+let Collider2D = class Collider2D extends Component {
+    shape = 'auto';
+    halfExtents = [0.5, 0.5];
+    radius = 0.5;
+    density = 1;
+    friction = 0.3;
+    restitution = 0;
+    isSensor = false;
+    /** The planck shape for this collider, resolving `auto` from the host geometry. */
+    toShape() {
+        switch (this.shape) {
+            case 'box': {
+                const [hx, hy] = this.halfExtents;
+                return new BoxShape(hx, hy);
+            }
+            case 'circle':
+                return new CircleShape(this.radius);
+            default:
+                return this.autoShape();
+        }
+    }
+    /** Fixture material/flags for `body.createFixture(shape, opt)`. */
+    fixtureOpt() {
+        return {
+            density: this.density,
+            friction: this.friction,
+            restitution: this.restitution,
+            isSensor: this.isSensor,
+        };
+    }
+    /** Derive a shape from the host mesh's geometry parameters. */
+    autoShape() {
+        const geom = this.node.geometry;
+        const p = geom?.parameters;
+        if (geom && p) {
+            switch (geom.type) {
+                case 'BoxGeometry':
+                case 'PlaneGeometry':
+                    return new BoxShape((p.width ?? 1) / 2, (p.height ?? 1) / 2);
+                case 'SphereGeometry':
+                case 'CircleGeometry':
+                    return new CircleShape(p.radius ?? 0.5);
+            }
+        }
+        return new BoxShape(0.5, 0.5); // fallback: unit box
+    }
+};
+__decorate([
+    property({ type: 'string', default: 'auto', description: 'auto | box | circle' })
+], Collider2D.prototype, "shape", void 0);
+__decorate([
+    property({ type: 'vec2', default: [0.5, 0.5], description: 'Box half-extents (shape="box")' })
+], Collider2D.prototype, "halfExtents", void 0);
+__decorate([
+    property({ type: 'float', default: 0.5, description: 'Radius (shape="circle")' })
+], Collider2D.prototype, "radius", void 0);
+__decorate([
+    property({ type: 'float', default: 1, description: 'Density (kg/m²); 0 for static' })
+], Collider2D.prototype, "density", void 0);
+__decorate([
+    property({ type: 'float', default: 0.3, description: 'Friction 0..1' })
+], Collider2D.prototype, "friction", void 0);
+__decorate([
+    property({ type: 'float', default: 0, description: 'Restitution (bounciness) 0..1' })
+], Collider2D.prototype, "restitution", void 0);
+__decorate([
+    property({ type: 'bool', default: false, description: 'A trigger: reports overlaps, no collision response' })
+], Collider2D.prototype, "isSensor", void 0);
+Collider2D = __decorate([
+    component({ name: 'Collider2D', description: 'A 2D collision shape (planck); the Physics2DSystem attaches it to the node’s RigidBody2D' })
+], Collider2D);
+export { Collider2D };

package/dist/Physics2D.d.ts

@@ -0,0 +1,17 @@
+import { Attachment } from '@scenoco-three/core';
+/**
+ * Scene-level 2D physics config: `<Physics2D gravity="0 -9.81" />` inside `<Scene>`.
+ *
+ * A pure config attachment — the `Physics2DSystem` (auto-run while the scene has
+ * 2D bodies) reads `gravity` and the solver iteration counts via
+ * `engine.findAttachment(Physics2D)`. The simulation runs in the XY plane: a
+ * body's position drives the node's `x`/`y` and its angle drives `rotation.z`.
+ *
+ * Unlike the Rapier add-on, no async init is needed — planck (Box2D) is pure JS.
+ */
+export declare class Physics2D extends Attachment {
+    gravity: number[];
+    velocityIterations: number;
+    positionIterations: number;
+    attach(): void;
+}

package/dist/Physics2D.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Attachment, attachment, property } from '@scenoco-three/core';
+/**
+ * Scene-level 2D physics config: `<Physics2D gravity="0 -9.81" />` inside `<Scene>`.
+ *
+ * A pure config attachment — the `Physics2DSystem` (auto-run while the scene has
+ * 2D bodies) reads `gravity` and the solver iteration counts via
+ * `engine.findAttachment(Physics2D)`. The simulation runs in the XY plane: a
+ * body's position drives the node's `x`/`y` and its angle drives `rotation.z`.
+ *
+ * Unlike the Rapier add-on, no async init is needed — planck (Box2D) is pure JS.
+ */
+let Physics2D = class Physics2D extends Attachment {
+    gravity = [0, -9.81];
+    velocityIterations = 8;
+    positionIterations = 3;
+    // Config only: the values are read by Physics2DSystem; nothing to apply here.
+    attach() { }
+};
+__decorate([
+    property({ type: 'vec2', default: [0, -9.81], description: 'Gravity vector (XY plane)' })
+], Physics2D.prototype, "gravity", void 0);
+__decorate([
+    property({ type: 'int', default: 8, description: 'Velocity solver iterations per step' })
+], Physics2D.prototype, "velocityIterations", void 0);
+__decorate([
+    property({ type: 'int', default: 3, description: 'Position solver iterations per step' })
+], Physics2D.prototype, "positionIterations", void 0);
+Physics2D = __decorate([
+    attachment({ name: 'Physics2D', target: 'Scene', group: 'physics2d', description: 'Scene 2D physics config (gravity, solver iterations)' })
+], Physics2D);
+export { Physics2D };

package/dist/Physics2DSystem.d.ts

@@ -0,0 +1,30 @@
+import { World } from 'planck';
+import { System } from '@scenoco-three/core';
+import { RigidBody2D } from './RigidBody2D.js';
+/**
+ * ECS-hybrid 2D physics on planck (Box2D). Registered for `RigidBody2D`, the
+ * engine auto-runs it while the scene contains 2D bodies and keeps
+ * `this.components` in sync. Each fixed step it reconciles the planck world with
+ * the live body set, drives kinematic bodies from their nodes, steps the world,
+ * and writes dynamic poses back to the XY plane (position → node.x/y, angle →
+ * node.rotation.z). Gravity/iterations come from the `<Physics2D>` attachment.
+ *
+ * Contacts are dispatched to components via duck-typed Unity-style hooks
+ * (`onCollisionEnter2D` / `onTriggerEnter2D` / …). They are queued during the
+ * step and delivered after it returns, so a hook may safely mutate the scene
+ * (e.g. destroy a brick) without corrupting the in-progress simulation.
+ *
+ * No async init is required — planck is pure JS.
+ */
+export declare class Physics2DSystem extends System<RigidBody2D> {
+    world?: World;
+    private readonly bodies;
+    private readonly contacts;
+    onAttach(): void;
+    fixedStep(dt: number): void;
+    onDetach(): void;
+    private createBody;
+    private queue;
+    private flushContacts;
+    private dispatch;
+}

package/dist/Physics2DSystem.js

@@ -0,0 +1,135 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { World, Vec2 } from 'planck';
+import { System, system } from '@scenoco-three/core';
+import { RigidBody2D } from './RigidBody2D.js';
+import { Collider2D } from './Collider2D.js';
+import { Physics2D } from './Physics2D.js';
+/**
+ * ECS-hybrid 2D physics on planck (Box2D). Registered for `RigidBody2D`, the
+ * engine auto-runs it while the scene contains 2D bodies and keeps
+ * `this.components` in sync. Each fixed step it reconciles the planck world with
+ * the live body set, drives kinematic bodies from their nodes, steps the world,
+ * and writes dynamic poses back to the XY plane (position → node.x/y, angle →
+ * node.rotation.z). Gravity/iterations come from the `<Physics2D>` attachment.
+ *
+ * Contacts are dispatched to components via duck-typed Unity-style hooks
+ * (`onCollisionEnter2D` / `onTriggerEnter2D` / …). They are queued during the
+ * step and delivered after it returns, so a hook may safely mutate the scene
+ * (e.g. destroy a brick) without corrupting the in-progress simulation.
+ *
+ * No async init is required — planck is pure JS.
+ */
+let Physics2DSystem = class Physics2DSystem extends System {
+    world;
+    bodies = new Map();
+    contacts = [];
+    onAttach() {
+        const cfg = this.engine.findAttachment(Physics2D);
+        const g = cfg?.gravity ?? [0, -9.81];
+        this.world = new World({ gravity: new Vec2(g[0] ?? 0, g[1] ?? -9.81) });
+        // Resolve contacts to nodes at event time and queue them; the side of the
+        // pair that owns a body may be gone by dispatch, but the nodes stay valid.
+        this.world.on('begin-contact', (contact) => this.queue(contact, 'enter'));
+        this.world.on('end-contact', (contact) => this.queue(contact, 'exit'));
+    }
+    fixedStep(dt) {
+        const world = this.world;
+        if (!world)
+            return;
+        // Reconcile bodies ↔ live components: create for new, remove for gone.
+        for (const rb of this.components)
+            if (!this.bodies.has(rb))
+                this.createBody(world, rb);
+        for (const [rb, body] of this.bodies) {
+            if (!this.components.includes(rb)) {
+                world.destroyBody(body);
+                this.bodies.delete(rb);
+                rb.body = undefined;
+            }
+        }
+        // Kinematic bodies are driven by their node (game code moves the node).
+        for (const [rb, body] of this.bodies) {
+            if (rb.kind === 'kinematic')
+                body.setTransform(new Vec2(rb.node.position.x, rb.node.position.y), rb.node.rotation.z);
+        }
+        const cfg = this.engine.findAttachment(Physics2D);
+        world.step(dt, cfg?.velocityIterations ?? 8, cfg?.positionIterations ?? 3);
+        // Dynamic bodies write their pose back to the scene graph (XY plane).
+        for (const [rb, body] of this.bodies) {
+            if (rb.kind !== 'dynamic')
+                continue;
+            const p = body.getPosition();
+            rb.node.position.x = p.x;
+            rb.node.position.y = p.y;
+            rb.node.rotation.z = body.getAngle();
+        }
+        this.flushContacts();
+    }
+    onDetach() {
+        for (const rb of this.bodies.keys())
+            rb.body = undefined;
+        this.bodies.clear();
+        this.contacts.length = 0;
+        this.world = undefined;
+    }
+    createBody(world, rb) {
+        const body = world.createBody({
+            type: rb.kind,
+            position: new Vec2(rb.node.position.x, rb.node.position.y),
+            angle: rb.node.rotation.z,
+            linearDamping: rb.linearDamping,
+            angularDamping: rb.angularDamping,
+            fixedRotation: rb.fixedRotation,
+            gravityScale: rb.gravityScale,
+            bullet: rb.bullet,
+        });
+        body.setUserData(rb);
+        // Attach the colliders declared on the same node.
+        for (const c of this.engine.getComponents(rb.node)) {
+            if (c instanceof Collider2D)
+                body.createFixture(c.toShape(), c.fixtureOpt());
+        }
+        this.bodies.set(rb, body);
+        rb.body = body;
+    }
+    queue(contact, phase) {
+        const fa = contact.getFixtureA();
+        const fb = contact.getFixtureB();
+        const rbA = fa.getBody().getUserData();
+        const rbB = fb.getBody().getUserData();
+        if (!rbA || !rbB)
+            return;
+        this.contacts.push({ a: rbA.node, b: rbB.node, sensor: fa.isSensor() || fb.isSensor(), phase });
+    }
+    flushContacts() {
+        if (this.contacts.length === 0)
+            return;
+        const batch = this.contacts.splice(0, this.contacts.length);
+        for (const { a, b, sensor, phase } of batch) {
+            this.dispatch(a, b, sensor, phase);
+            this.dispatch(b, a, sensor, phase);
+        }
+    }
+    dispatch(node, other, sensor, phase) {
+        for (const c of this.engine.getComponents(node)) {
+            const h = c;
+            const fn = sensor
+                ? phase === 'enter'
+                    ? h.onTriggerEnter2D
+                    : h.onTriggerExit2D
+                : phase === 'enter'
+                    ? h.onCollisionEnter2D
+                    : h.onCollisionExit2D;
+            fn?.call(c, other);
+        }
+    }
+};
+Physics2DSystem = __decorate([
+    system(RigidBody2D)
+], Physics2DSystem);
+export { Physics2DSystem };

package/dist/RigidBody2D.d.ts

@@ -0,0 +1,29 @@
+import type { Body } from 'planck';
+import { Component } from '@scenoco-three/core';
+/**
+ * Marks the host node as a Box2D (planck) 2D rigid body — plain data the
+ * `Physics2DSystem` reconciles into the world. Pair it with one or more
+ * `<Collider2D>` on the same node to give it shape. The system stamps the live
+ * planck `body` onto this component once built.
+ *
+ *   dynamic   — simulated; physics drives the node's x/y and rotation.z
+ *   static    — never moves (walls, ground)
+ *   kinematic — moved by your code (set node.position); the body follows it,
+ *               pushing dynamic bodies (paddles, moving platforms)
+ */
+export declare class RigidBody2D extends Component {
+    kind: string;
+    linearDamping: number;
+    angularDamping: number;
+    fixedRotation: boolean;
+    gravityScale: number;
+    bullet: boolean;
+    /** The live planck body, set by the Physics2DSystem after it builds it. */
+    body?: Body;
+    /** Apply an instantaneous impulse at the body's center (world space), waking it. */
+    applyImpulse(x: number, y: number): void;
+    /** Set the linear velocity (world space), waking the body. */
+    setVelocity(x: number, y: number): void;
+    /** Current linear velocity, or `[0, 0]` before the body exists. */
+    getVelocity(): [number, number];
+}

package/dist/RigidBody2D.js

@@ -0,0 +1,64 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Component, component, property } from '@scenoco-three/core';
+/**
+ * Marks the host node as a Box2D (planck) 2D rigid body — plain data the
+ * `Physics2DSystem` reconciles into the world. Pair it with one or more
+ * `<Collider2D>` on the same node to give it shape. The system stamps the live
+ * planck `body` onto this component once built.
+ *
+ *   dynamic   — simulated; physics drives the node's x/y and rotation.z
+ *   static    — never moves (walls, ground)
+ *   kinematic — moved by your code (set node.position); the body follows it,
+ *               pushing dynamic bodies (paddles, moving platforms)
+ */
+let RigidBody2D = class RigidBody2D extends Component {
+    kind = 'dynamic';
+    linearDamping = 0;
+    angularDamping = 0;
+    fixedRotation = false;
+    gravityScale = 1;
+    bullet = false;
+    /** The live planck body, set by the Physics2DSystem after it builds it. */
+    body;
+    /** Apply an instantaneous impulse at the body's center (world space), waking it. */
+    applyImpulse(x, y) {
+        if (this.body)
+            this.body.applyLinearImpulse({ x, y }, this.body.getWorldCenter(), true);
+    }
+    /** Set the linear velocity (world space), waking the body. */
+    setVelocity(x, y) {
+        this.body?.setLinearVelocity({ x, y });
+    }
+    /** Current linear velocity, or `[0, 0]` before the body exists. */
+    getVelocity() {
+        const v = this.body?.getLinearVelocity();
+        return v ? [v.x, v.y] : [0, 0];
+    }
+};
+__decorate([
+    property({ type: 'string', default: 'dynamic', description: 'dynamic | static | kinematic' })
+], RigidBody2D.prototype, "kind", void 0);
+__decorate([
+    property({ type: 'float', default: 0 })
+], RigidBody2D.prototype, "linearDamping", void 0);
+__decorate([
+    property({ type: 'float', default: 0 })
+], RigidBody2D.prototype, "angularDamping", void 0);
+__decorate([
+    property({ type: 'bool', default: false, description: 'Lock rotation (common for characters)' })
+], RigidBody2D.prototype, "fixedRotation", void 0);
+__decorate([
+    property({ type: 'float', default: 1, description: 'Multiplier on world gravity for this body' })
+], RigidBody2D.prototype, "gravityScale", void 0);
+__decorate([
+    property({ type: 'bool', default: false, description: 'Continuous collision for fast bodies (e.g. a ball)' })
+], RigidBody2D.prototype, "bullet", void 0);
+RigidBody2D = __decorate([
+    component({ name: 'RigidBody2D', description: 'A 2D physics body (planck/Box2D); pair with <Collider2D>. Needs a <Physics2D> scene.' })
+], RigidBody2D);
+export { RigidBody2D };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { Physics2DSystem } from './Physics2DSystem.js';
+export { RigidBody2D } from './RigidBody2D.js';
+export { Collider2D } from './Collider2D.js';
+export { Physics2D } from './Physics2D.js';
+/**
+ * The XML tags this package registers — read by the compiler/Vite plugin
+ * (`registerPackages`) so a scene that uses them validates and imports the
+ * package. The convention for any SceNoCo tag package.
+ */
+export declare const sceneTags: readonly ["RigidBody2D", "Collider2D", "Physics2D"];

package/dist/index.js

@@ -0,0 +1,26 @@
+// `@scenoco-three/box2d` — 2D physics for SceNoCo on planck (a pure-JS Box2D
+// port), built entirely on the public seams: a `Physics2DSystem extends System`,
+// `@component` `RigidBody2D`/`Collider2D`, and a `<Physics2D>` `@attachment`.
+// Core has no physics dependency; an app that doesn't import this package ships
+// no 2D physics. The 3D counterpart is `@scenoco-three/rapier`.
+//
+// Importing this module registers the `RigidBody2D`, `Collider2D`, and
+// `Physics2D` tags (decorator side effects) — hence the package is `sideEffects`.
+//
+// Unlike Rapier, planck is pure JS: there is NO async init — register the tags by
+// importing the package and load the scene directly.
+//
+// The simulation runs in the XY plane: a body's position drives the node's x/y
+// and its angle drives rotation.z. Contacts are delivered to components via
+// duck-typed Unity-style hooks: onCollisionEnter2D / onCollisionExit2D /
+// onTriggerEnter2D / onTriggerExit2D, each receiving the other node.
+export { Physics2DSystem } from './Physics2DSystem.js';
+export { RigidBody2D } from './RigidBody2D.js';
+export { Collider2D } from './Collider2D.js';
+export { Physics2D } from './Physics2D.js';
+/**
+ * The XML tags this package registers — read by the compiler/Vite plugin
+ * (`registerPackages`) so a scene that uses them validates and imports the
+ * package. The convention for any SceNoCo tag package.
+ */
+export const sceneTags = ['RigidBody2D', 'Collider2D', 'Physics2D'];

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@scenoco-three/box2d",
+  "version": "0.1.0",
+  "description": "Box2D (planck) 2D physics for SceNoCo: <Physics2D> setting + RigidBody2D/Collider2D components on the System seam",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": ["three", "threejs", "physics", "2d", "box2d", "planck", "scene", "components", "gamedev"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "//sideEffects": "Importing the package registers its @component/@attachment tags (decorator side effects), so it must not be tree-shaken away when imported for registration.",
+  "sideEffects": true,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "npm --prefix ../core run build && tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@scenoco-three/core": "^0.1.0",
+    "planck": "^1.5.0"
+  },
+  "peerDependencies": {
+    "three": ">=0.160.0"
+  }
+}