@simpludify/core 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 oz-coden
+
+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

@@ -1,3 +1,21 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @simpludify/core
+
+Experimental v0.1.0 of Simpludify, a code-first TypeScript 2D engine. APIs may change between 0.x releases. This package contains host-independent Scene/Actor/Component, collision, geometry, tilemaps, tween/animation, input and Canvas UI models. It has no browser or Node runtime dependencies.
+
+The v0.1.0 distribution is being prepared; registry availability is not yet confirmed. Once published:
+
+```sh
+npm install @simpludify/core@0.1.0
+```
+
+```js
+import { Engine, Actor, Transform } from "@simpludify/core";
+const engine = new Engine();
+const actor = new Actor();
+actor.add(new Transform({ x: 10, y: 20 }));
+engine.scene.add(actor);
+engine.step(1 / 60);
+engine.dispose();
+```
+
+ESM only, ES2022, Node >=22.12 for headless usage. No CommonJS or renderer is included. For browser presentation install `@simpludify/web`, which depends on this package. JavaScript source maps embed the original sources; declarations are included. [Repository and API](https://github.com/oz-coden/Simpludify) · [Documentation](https://github.oz-coden.com/Simpludify/). MIT.

package/dist/animation/actor-tween.d.ts

@@ -0,0 +1,10 @@
+import type { Actor } from "../scene/actor.js";
+/** Explicit draw-only channels. World Transform/Motion/CollisionBody are never tweened. */
+export declare function actorTween(actor: Actor): Readonly<{
+    offsetX: import("../index.js").TweenBinding;
+    offsetY: import("../index.js").TweenBinding;
+    rotation: import("../index.js").TweenBinding;
+    scaleX: import("../index.js").TweenBinding;
+    scaleY: import("../index.js").TweenBinding;
+    opacity: import("../index.js").TweenBinding;
+}>;

package/dist/animation/sprite-animation.d.ts

@@ -0,0 +1,62 @@
+import type { SpriteSheet } from "../graphics/sprite-sheet.js";
+import { Component, type ComponentType, type UpdateContext } from "../scene/component.js";
+/** Uniform frame timing in simulation seconds; default 8fps and loop=true. */
+export type SpriteClip<FrameName extends string = never> = Readonly<{
+    frames: readonly (number | FrameName)[];
+    loop?: boolean;
+} & ({
+    fps?: number;
+    frameSeconds?: never;
+} | {
+    fps?: never;
+    frameSeconds: number;
+})>;
+export declare const SpriteAnimationState: {
+    readonly Playing: "playing";
+    readonly Paused: "paused";
+    readonly Stopped: "stopped";
+    readonly Completed: "completed";
+};
+export type SpriteAnimationState = (typeof SpriteAnimationState)[keyof typeof SpriteAnimationState];
+export interface SpriteAnimationOptions<Name extends string, FrameName extends string> {
+    sheet: SpriteSheet<FrameName>;
+    clips: Readonly<Record<Name, SpriteClip<NoInfer<FrameName>>>>;
+    initial?: NoInfer<Name>;
+    onComplete?: (name: NoInfer<Name>) => void;
+}
+/** One independent playback cursor per Actor. Requires an existing Renderable. */
+export declare class SpriteAnimation<Name extends string = string, FrameName extends string = never> extends Component {
+    static readonly type: ComponentType<SpriteAnimation>;
+    readonly type: ComponentType<SpriteAnimation<string, never>>;
+    readonly phase: "late-update";
+    private readonly clips;
+    private readonly complete;
+    private selected;
+    private clip;
+    private status;
+    private cursor;
+    private time;
+    private view;
+    private written;
+    private image;
+    constructor(options: SpriteAnimationOptions<Name, FrameName>);
+    get current(): Name;
+    get state(): SpriteAnimationState;
+    /** Zero-based position within the selected clip, not a sheet index. */
+    get frameIndex(): number;
+    /** Elapsed simulation seconds within the selected clip; wraps when looping. */
+    get elapsed(): number;
+    private assertAlive;
+    private show;
+    protected onAttach(): void;
+    /** Same playing/paused clip is a no-op. restart=true or stopped/completed restarts. */
+    play(name: Name, options?: {
+        restart?: boolean;
+    }): void;
+    pause(): void;
+    resume(): void;
+    /** Reset to the first frame; does not emit completion. */
+    stop(): void;
+    update({ delta }: UpdateContext): void;
+    protected onDestroy(): void;
+}

package/dist/components.d.ts

@@ -0,0 +1,2 @@
+export * from "./game/motion.js";
+export * from "./graphics/components.js";

package/dist/foundation/cancellation.d.ts

@@ -0,0 +1,13 @@
+/** Owner cancellation, independent of browser AbortSignal and host event types. */
+export interface CancellationSignal {
+    readonly aborted: boolean;
+    onCancel(callback: () => void): () => void;
+    throwIfCancelled(): void;
+}
+export declare class Cancellation {
+    private dead;
+    private readonly listeners;
+    readonly signal: CancellationSignal;
+    constructor();
+    cancel(): void;
+}

package/dist/foundation/diagnostics.d.ts

@@ -0,0 +1,10 @@
+export declare class EngineError extends Error {
+    readonly code: string;
+    readonly details: Readonly<Record<string, unknown>>;
+    constructor(code: string, message: string, details?: Readonly<Record<string, unknown>>);
+    toJSON(): {
+        code: string;
+        message: string;
+    };
+}
+export declare function positive(value: number, name: string): number;

package/dist/foundation/easing.d.ts

@@ -0,0 +1,11 @@
+/** Pure normalized easing functions. Custom easing must return a finite value in [0,1]. */
+export type EasingFunction = (progress: number) => number;
+export declare const Easing: Readonly<{
+    Linear: (t: number) => number;
+    InQuad: (t: number) => number;
+    OutQuad: (t: number) => number;
+    InOutQuad: (t: number) => number;
+    InCubic: (t: number) => number;
+    OutCubic: (t: number) => number;
+    InOutCubic: (t: number) => number;
+}>;

package/dist/foundation/events.d.ts

@@ -0,0 +1,18 @@
+import { type LifetimeOwner } from "./lifetime.js";
+export interface EventType<T> {
+    readonly id: symbol;
+    readonly name: string;
+    readonly payload?: (value: T) => T;
+}
+export declare function defineEvent<T>(name: string): EventType<T>;
+/** Synchronous registration-order delivery. Recursive delivery of the same token is rejected. */
+export declare class EventBus {
+    private readonly listeners;
+    private readonly dispatching;
+    private dead;
+    private assertAlive;
+    on<T>(type: EventType<T>, handler: (payload: T) => void, owner?: LifetimeOwner): () => void;
+    emit<T>(type: EventType<T>, payload: NoInfer<T>): void;
+    listenerCount<T>(type?: EventType<T>): number;
+    dispose(): void;
+}

package/dist/foundation/grid.d.ts

@@ -0,0 +1,22 @@
+export type GridVisitor<T> = (value: T, x: number, y: number) => void;
+/** Fixed-size, row-major data. Cells retain values/references without owning them. */
+export declare class Grid<T> {
+    #private;
+    static get maxCells(): number;
+    /** The same initial value/reference is stored in every cell, including functions. */
+    constructor(width: number, height: number, initial: T);
+    /** Calls initialize(x,y) once per cell, left-to-right then top-to-bottom. */
+    static generate<T>(width: number, height: number, initialize: (x: number, y: number) => T): Grid<T>;
+    get width(): number;
+    get height(): number;
+    /** False for noninteger/nonfinite/out-of-range coordinates; never clips. */
+    inBounds(x: number, y: number): boolean;
+    get(x: number, y: number): T;
+    set(x: number, y: number, value: T): void;
+    /** Replaces every cell with the same value/reference; does not dispose old values. */
+    fill(value: T): void;
+    /** Live row-major traversal; later cells observe writes made by earlier visits. */
+    forEach(visit: GridVisitor<T>): void;
+    /** Fully contained rectangle, with nonnegative integer extents; empty is valid. */
+    forEachRect(x: number, y: number, width: number, height: number, visit: GridVisitor<T>): void;
+}

package/dist/foundation/lifetime.d.ts

@@ -0,0 +1,14 @@
+export interface LifetimeOwner {
+    readonly disposed: boolean;
+    onDispose(callback: () => void): () => void;
+}
+/** Lazy, removable LIFO cleanup. Disposed owners cannot acquire new resources. */
+export declare class Lifetime implements LifetimeOwner {
+    private callbacks;
+    private dead;
+    get disposed(): boolean;
+    onDispose(callback: () => void): () => void;
+    dispose(): void;
+}
+/** Execute every cleanup even when one throws. */
+export declare function cleanupAll(actions: Iterable<() => void>, message: string): void;

package/dist/foundation/random.d.ts

@@ -0,0 +1,44 @@
+export declare const RANDOM_ALGORITHM = "lcg32-fnv1a-utf16le-v1";
+export declare const DEFAULT_RANDOM_STREAM = "$default";
+export interface RandomState {
+    readonly name: string;
+    readonly seed: number;
+    readonly state: number;
+    readonly calls: number;
+}
+export interface RandomSnapshot {
+    readonly algorithm: typeof RANDOM_ALGORITHM;
+    readonly seed: number;
+    readonly streams: readonly RandomState[];
+}
+/** FNV-1a over master seed (four LE bytes), then exact UTF-16 code units (two LE bytes each). */
+export declare function deriveStreamSeed(seed: number, name: string): number;
+export declare class RandomStream {
+    private readonly initial;
+    private current;
+    private count;
+    private dead;
+    /** @internal Streams are acquired from RandomManager.stream(). */
+    constructor(initial: number);
+    get seed(): number;
+    get state(): number;
+    get calls(): number;
+    get disposed(): boolean;
+    next(): number;
+    /** @internal */ dispose(): void;
+}
+/** Independent deterministic streams. State survives Scene replacement and ends with its owner. */
+export declare class RandomManager {
+    private readonly initial;
+    private readonly streams;
+    private readonly defaultStream;
+    private dead;
+    constructor(seed?: number);
+    get seed(): number;
+    get disposed(): boolean;
+    private alive;
+    next(): number;
+    stream(name: string): RandomStream;
+    snapshot(): RandomSnapshot;
+    dispose(): void;
+}

package/dist/foundation/timers.d.ts

@@ -0,0 +1,11 @@
+import { type LifetimeOwner } from "./lifetime.js";
+export declare class SimulationTimers {
+    private readonly timers;
+    private dead;
+    private plan;
+    schedule(seconds: number, callback: () => void, repeat: boolean, owner?: LifetimeOwner): () => void;
+    /** Capture eligibility before any Scene update phase. */
+    beginStep(): void;
+    step(seconds: number): void;
+    dispose(): void;
+}

package/dist/foundation/tween.d.ts

@@ -0,0 +1,159 @@
+import { type EasingFunction } from "./easing.js";
+import type { LifetimeOwner } from "./lifetime.js";
+export type TweenCancelReason = "cancelled" | "stopped" | "replaced" | "external-write" | "target-unavailable" | "owner-disposed" | "scheduler-disposed" | "error";
+export interface TweenBindingOptions {
+    readonly target: object;
+    readonly key: PropertyKey;
+    readonly read: () => number;
+    readonly write: ((value: number) => void) | ((value: number) => boolean);
+    readonly owner?: LifetimeOwner;
+    readonly scope?: () => object | undefined;
+    readonly valid?: () => boolean;
+    readonly validate?: (value: number) => void;
+    readonly stamp?: () => unknown;
+    readonly watch?: (invalidate: (reason?: TweenCancelReason) => void) => () => void;
+}
+/** Explicit numeric write capability. target/key identifies a channel, not a reflected object path. */
+export declare class TweenBinding {
+    readonly options: TweenBindingOptions;
+    readonly key: string | symbol;
+    constructor(options: TweenBindingOptions);
+}
+export interface TweenOptions {
+    readonly duration: number;
+    readonly from?: number;
+    readonly easing?: EasingFunction;
+    readonly delay?: number;
+    /** Additional iterations, or Infinity. */
+    readonly repeat?: number;
+    readonly yoyo?: boolean;
+}
+type NumberRecipe = Readonly<{
+    kind: "number";
+    binding: TweenBinding;
+    to: number;
+    duration: number;
+    delay: number;
+    repeat: number;
+    yoyo: boolean;
+    easing: EasingFunction;
+    from: number | undefined;
+}>;
+export type TweenRecipe = NumberRecipe | Readonly<{
+    kind: "delay";
+    duration: number;
+}> | Readonly<{
+    kind: "sequence" | "parallel";
+    children: readonly TweenRecipe[];
+}>;
+export declare function tweenFinite(value: number, label: string): number;
+type Equal<X, Y, A, B> = (<T>() => T extends X ? 1 : 2) extends <T>() => (T extends Y ? 1 : 2) ? A : B;
+export type TweenNumericKey<T> = {
+    [K in keyof T]-?: T[K] extends number ? Equal<Pick<T, K>, {
+        -readonly [P in K]: T[P];
+    }, K, never> : never;
+}[keyof T];
+export declare const Tween: Readonly<{
+    bind: (options: TweenBindingOptions) => TweenBinding;
+    /** Only writable own numeric data properties on plain records. Classes need explicit adapters. */
+    property<T extends object>(target: T, key: TweenNumericKey<T>): TweenBinding;
+    to(binding: TweenBinding, to: number, options: TweenOptions): TweenRecipe;
+    delay: (duration: number) => TweenRecipe;
+    sequence: (...children: TweenRecipe[]) => TweenRecipe;
+    parallel: (...children: TweenRecipe[]) => TweenRecipe;
+}>;
+interface Track {
+    definition: NumberRecipe;
+    start: number;
+    end: number;
+    from: number | undefined;
+    done: boolean;
+    channel?: Channel | undefined;
+}
+interface Channel {
+    binding: TweenBinding;
+    expected: number;
+    stamp: unknown;
+}
+declare function compile(root: TweenRecipe): {
+    duration: number;
+    bindings: TweenBinding[];
+    tracks: Track[];
+};
+export interface TweenPlayOptions {
+    readonly owner?: LifetimeOwner;
+    readonly conflict?: "replace" | "error";
+    readonly onComplete?: (playback: TweenPlayback) => void;
+    readonly onCancel?: (reason: TweenCancelReason, playback: TweenPlayback) => void;
+}
+export type TweenState = "playing" | "paused" | "completed" | "cancelled";
+/** One playback, terminal once. A finished handle drops channels, targets and scheduler references. */
+export declare class TweenPlayback {
+    private status;
+    private time;
+    private updating;
+    private cause;
+    private removers;
+    private channels;
+    private tracks;
+    private scheduler;
+    private complete;
+    private cancelled;
+    readonly duration: number;
+    /** @internal Created by Scheduler.play after recipe validation. */
+    constructor(scheduler: TweenScheduler, plan: ReturnType<typeof compile>, options: TweenPlayOptions);
+    get state(): TweenState;
+    get elapsed(): number;
+    get reason(): TweenCancelReason | undefined;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+    stop(): void;
+    /** Skip finite delays/iterations and apply terminal values. Infinite playback cannot finish. */
+    finish(): void;
+    private get terminal();
+    /** @internal */ valid(scope: object | undefined): boolean;
+    /** @internal */ own(owners: Iterable<LifetimeOwner>): void;
+    /** @internal Claims are reserved before replaced-owner callbacks run. */
+    claim(): Set<TweenPlayback>;
+    /** @internal */ conflicts(): boolean;
+    /** @internal */ watch(): void;
+    private release;
+    private end;
+    /** @internal */ interrupt(reason: TweenCancelReason): void;
+    /** @internal */ advance(delta: number): void;
+    private updateTo;
+    private advanceTo;
+}
+/** Explicit clock. Scene owns automatic clocks; standalone schedulers are advanced by their caller. */
+export declare class TweenScheduler {
+    private readonly entries;
+    private roster;
+    private dirty;
+    private plan;
+    private advancing;
+    private dead;
+    private rate;
+    private owner;
+    private removeOwner;
+    readonly scope: object | undefined;
+    constructor(options?: {
+        owner?: LifetimeOwner;
+        scope?: object;
+    });
+    get disposed(): boolean;
+    /** @internal */ get available(): boolean;
+    get diagnostics(): {
+        active: number;
+    };
+    get speed(): number;
+    set speed(value: number);
+    play(definition: TweenRecipe, options?: TweenPlayOptions): TweenPlayback;
+    /** @internal Eligibility snapshot before the Scene input/update phases. */
+    beginStep(): void;
+    advance(seconds: number): void;
+    /** @internal */ advanceCaptured(seconds: number): void;
+    /** @internal */ remove(p: TweenPlayback): void;
+    dispose(): void;
+}
+export {};

package/dist/foundation/version.d.ts

@@ -0,0 +1,2 @@
+/** Source workspace version; checked against package.json by the build validator. */
+export declare const ENGINE_VERSION = "0.1.0";

package/dist/game/character.d.ts

@@ -0,0 +1,21 @@
+import { type VisualSource } from "../graphics/components.js";
+import type { ActionReader } from "../interaction/actions.js";
+import { Actor } from "../scene/actor.js";
+export interface CharacterOptions {
+    id?: string;
+    x?: number;
+    y?: number;
+    speed?: number;
+    size?: number;
+    color?: number;
+    movement?: ActionReader<"axis2d">;
+    source?: VisualSource;
+}
+export declare class CharacterActor extends Actor {
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+}
+/** Composition preset; the simulation has no knowledge of characters. */
+export declare function Character(options?: CharacterOptions): CharacterActor;

package/dist/game/collider.d.ts

@@ -0,0 +1,58 @@
+import { type EventType } from "../foundation/events.js";
+import type { Actor } from "../scene/actor.js";
+import { Component, type ComponentType } from "../scene/component.js";
+export declare const CollisionShape: {
+    readonly Box: "box";
+    readonly Circle: "circle";
+};
+export type CollisionShape = (typeof CollisionShape)[keyof typeof CollisionShape];
+import { CollisionResponse } from "./collision-policy.js";
+export { CollisionResponse } from "./collision-policy.js";
+type ShapeOptions = {
+    shape?: typeof CollisionShape.Box;
+    width?: number;
+    height?: number;
+} | {
+    shape: typeof CollisionShape.Circle;
+    radius?: number;
+};
+export type ColliderOptions = ShapeOptions & {
+    response?: CollisionResponse;
+    offsetX?: number;
+    offsetY?: number;
+    layer?: number;
+    mask?: number;
+};
+export interface ContactGeometry {
+    /** Unit normal from self toward other at detection, before position correction. */
+    readonly normalX: number;
+    readonly normalY: number;
+    readonly depth: number;
+    readonly response: CollisionResponse;
+    readonly resolved: boolean;
+}
+export interface Contact extends ContactGeometry {
+    readonly self: Collider;
+    readonly other: Collider;
+    readonly selfActor: Actor;
+    readonly otherActor: Actor;
+}
+export declare const ContactEnter: EventType<Contact>;
+export declare const ContactStay: EventType<Contact>;
+export declare const ContactExit: EventType<Contact>;
+/** Geometry and contact policy. CollisionBody separately controls position correction. */
+export declare class Collider extends Component {
+    static readonly type: ComponentType<Collider>;
+    readonly type: ComponentType<Collider>;
+    readonly response: CollisionResponse;
+    readonly shape: CollisionShape;
+    readonly width: number;
+    readonly height: number;
+    readonly radius: number;
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly layer: number;
+    readonly mask: number;
+    constructor(options?: ColliderOptions);
+    /** @internal */ notify<T>(type: EventType<T>, contact: T): void;
+}

package/dist/game/collision-body.d.ts

@@ -0,0 +1,18 @@
+import { Component, type ComponentType } from "../scene/component.js";
+export declare const BodyType: {
+    readonly Static: "static";
+    readonly Dynamic: "dynamic";
+};
+export type BodyType = (typeof BodyType)[keyof typeof BodyType];
+/** Position-correction participation, not velocity integration or a rigid body. */
+export declare class CollisionBody extends Component {
+    static readonly type: ComponentType<CollisionBody>;
+    readonly type: ComponentType<CollisionBody>;
+    readonly motion: BodyType;
+    readonly mass: number;
+    constructor(options?: {
+        motion?: BodyType;
+        mass?: number;
+    });
+    get inverseMass(): number;
+}

package/dist/game/collision-contact.d.ts

@@ -0,0 +1,15 @@
+import type { ContactGeometry } from "./collider.js";
+import type { Manifold } from "./collision-geometry.js";
+import type { CollisionResponse } from "./collision-policy.js";
+export type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export interface ContactObservation {
+    seen: number;
+    readonly aContact: Mutable<ContactGeometry>;
+    readonly bContact?: Mutable<ContactGeometry>;
+}
+/** One observation path for both public payload families. */
+export declare function observeContact(pair: ContactObservation, pass: number, manifold: Manifold, response: CollisionResponse, sign?: number): void;
+export type ContactPhase = "enter" | "stay" | "exit";
+export declare function contactPhase(entered: boolean, active: boolean): ContactPhase;

package/dist/game/collision-geometry.d.ts

@@ -0,0 +1,36 @@
+import type { Transform } from "../graphics/components.js";
+import type { Actor } from "../scene/actor.js";
+import { type Collider } from "./collider.js";
+export interface GeometryEntry {
+    readonly actor: Actor;
+    readonly collider: Collider;
+    readonly transform: Transform;
+    readonly geometry: Geometry;
+}
+/** Narrow phase needs shape data only, not Actor ownership or a Transform. */
+export interface ManifoldEntry {
+    readonly collider: Pick<Collider, "shape">;
+    readonly geometry: Geometry;
+}
+export interface Manifold {
+    normalX: number;
+    normalY: number;
+    depth: number;
+}
+export declare function createGeometry(): Geometry;
+export interface Geometry {
+    x: number;
+    y: number;
+    hx: number;
+    hy: number;
+    radius: number;
+    cos: number;
+    sin: number;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export declare function updateGeometry(entry: GeometryEntry): boolean;
+/** Exact existing circle/OBB tests, extended to return a minimum translation normal. */
+export declare function contactManifold(a: ManifoldEntry, b: ManifoldEntry, out: Manifold, tolerance?: number): boolean;

package/dist/game/collision-policy.d.ts

@@ -0,0 +1,15 @@
+export declare const CollisionResponse: {
+    readonly Trigger: "trigger";
+    readonly Solid: "solid";
+};
+export type CollisionResponse = (typeof CollisionResponse)[keyof typeof CollisionResponse];
+export interface CollisionPolicy {
+    readonly response: CollisionResponse;
+    readonly layer: number;
+    readonly mask: number;
+}
+export declare function collisionResponse(value: CollisionResponse): CollisionResponse;
+export declare function collisionBits(value: number, name: string, allowZero: boolean): number;
+export declare function allowsPair(a: CollisionPolicy, b: CollisionPolicy): boolean;
+export declare function pairResponse(a: CollisionPolicy, b: CollisionPolicy): CollisionResponse;
+export declare function samePolicy(a: CollisionPolicy | null, b: CollisionPolicy | null): boolean;

package/dist/game/collision-response.d.ts

@@ -0,0 +1,4 @@
+import type { Transform } from "../graphics/components.js";
+import type { Manifold } from "./collision-geometry.js";
+/** Translate along the minimum separation axis, preserving tangential movement intent. */
+export declare function correctPositions(a: Pick<Transform, "x" | "y">, b: Pick<Transform, "x" | "y">, contact: Manifold, ia: number, ib: number): boolean;