murow 0.1.1 → 0.1.3

package/dist/types/game/loop/ticker-schedule.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Fixed-capacity, zero-GC scheduler of tick-interval callbacks for the game loop.
+ *
+ * Schedules are stored in a pre-allocated object pool indexed by a {@link SlotMap}
+ * slot, so registering and cancelling reuse objects instead of producing garbage.
+ * Ids returned by {@link every} pack the slot with a generation counter, so an id
+ * left over from a cancelled schedule can never cancel the schedule that later
+ * reuses its slot.
+ */
+export declare class TickerSchedule {
+    private readonly _capacity;
+    private readonly _slots;
+    private readonly _generations;
+    private readonly _pool;
+    private _dirty;
+    private _running;
+    constructor(capacity: number);
+    /**
+     * Number of live schedules.
+     */
+    get size(): number;
+    /**
+     * Maximum number of simultaneously live schedules.
+     */
+    get capacity(): number;
+    /**
+     * Registers a callback to fire every `intervalTicks`, starting `intervalTicks`
+     * after `currentTick`. Returns a stable id for {@link clear}, or `-1` if the
+     * scheduler is at capacity.
+     */
+    every(intervalTicks: number, cb: () => void, currentTick: number): number;
+    /**
+     * Cancels the schedule for `id`. No-op (returns `false`) if the id is stale,
+     * unknown, or already cancelled.
+     */
+    clear(id: number): boolean;
+    /**
+     * Cancels every live schedule.
+     */
+    clearAll(): void;
+    /**
+     * Fires every schedule whose interval has elapsed at `currentTick`, then
+     * realigns it relative to `currentTick` (a long frame fires once, not a burst).
+     */
+    run(currentTick: number): void;
+    /**
+     * Re-anchors every live schedule's next fire relative to `baseTick`. Called
+     * when the loop restarts and the tick count resets.
+     */
+    rebase(baseTick: number): void;
+    private _compact;
+}

package/dist/types/renderer/index.d.ts

@@ -13,3 +13,4 @@ export * from "./prefab-bucket";
 export * from "./prefab-bucket/specs";
 export { PrefabBucket } from "./prefab-bucket/concrete";
 export type { PrefabBucket2D, PrefabBucket3D } from "./prefab-bucket/concrete";
+export * from "./raycast";

package/dist/types/renderer/prefab-bucket/concrete.d.ts

@@ -16,7 +16,8 @@
  * bucket.get('typo');    // ❌ TS error: '"typo"' not in '"minion" | "floor"'
  * ```
  */
-import { BasePrefabBucket, type StringOr } from './index';
+import { BasePrefabBucket, type SpecWithHitbox, type StringOr } from './index';
+import type { HitboxLibrary } from '../../core/hitbox/hitbox-library';
 import type { CompositePrefab, PartOffset, Prefab2D, Prefab2DSpec, Prefab3D, Prefab3DSpec, PrefabFor } from './specs';
 type SpecForMode<M> = M extends '3d' ? Prefab3DSpec : Prefab2DSpec;
 type PrefabUnionForMode<M> = M extends '3d' ? Prefab3D : Prefab2D;
@@ -27,20 +28,29 @@ type PrefabUnionForMode<M> = M extends '3d' ? Prefab3D : Prefab2D;
  * to register new specs and their prefab types. Call `load` to parse all registered
  * specs and populate the bucket's internal prefab registry.
  */
-export declare class PrefabBucket<M extends '2d' | '3d' = '3d', Specs extends Record<string, SpecForMode<M>> = {}> extends BasePrefabBucket<M, SpecForMode<M>, PrefabUnionForMode<M>, Specs> {
+export declare class PrefabBucket<M extends '2d' | '3d' = '3d', Specs extends Record<string, SpecForMode<M>> = {}, HB extends string = never> extends BasePrefabBucket<M, SpecForMode<M>, PrefabUnionForMode<M>, Specs, HB> {
+    private _hitboxLibrary;
     constructor(mode: M);
+    /**
+     * Register the hitbox library backing this bucket. Specs may then set
+     * `hitbox` to any of the library's names, autocompleted and type-checked.
+     */
+    hitboxes<N extends string>(library: HitboxLibrary<M, N>): PrefabBucket<M, Specs, N>;
+    /** The registered hitbox library, or `null` if none was set. */
+    get hitboxLibrary(): HitboxLibrary<M> | null;
     /**
      * Add a spec. Chains return the subclass type so the bucket variable's
      * static type accumulates id→spec mappings, enabling `get` to narrow.
+     * When a hitbox library is registered, `hitbox` must be one of its names.
      */
-    add<const S extends SpecForMode<M>>(spec: S): PrefabBucket<M, Specs & {
+    add<const S extends SpecWithHitbox<SpecForMode<M>, HB>>(spec: S): PrefabBucket<M, Specs & {
         [K in S['id']]: S;
-    }>;
-    addAll<const Ss extends readonly SpecForMode<M>[]>(specs: Ss): PrefabBucket<M, Specs & {
+    }, HB>;
+    addAll<const Ss extends readonly SpecWithHitbox<SpecForMode<M>, HB>[]>(specs: Ss): PrefabBucket<M, Specs & {
         [K in Ss[number]['id']]: Extract<Ss[number], {
             id: K;
         }>;
-    }>;
+    }, HB>;
     /**
      * Return the parsed prefab variant for this id. Narrow type — `get('minion')`
      * returns `GltfPrefab` (with `.animations`, `.jointCount`), not the union.

package/dist/types/renderer/prefab-bucket/index.d.ts

@@ -22,6 +22,10 @@ export type PrefabMode = '2d' | '3d';
  * suggestions for the known set.
  */
 export type StringOr<T extends string> = T | (string & {});
+/** A spec union with its `hitbox` field constrained to the hitbox names `HB`. */
+export type SpecWithHitbox<S, HB extends string> = S extends unknown ? Omit<S, 'hitbox'> & {
+    readonly hitbox?: StringOr<HB>;
+} : never;
 export interface PrefabSpecBase {
     readonly type: string;
     readonly id: string;
@@ -56,7 +60,7 @@ export interface PrefabParserContext {
  */
 export type PrefabParser<Spec extends PrefabSpecBase = PrefabSpecBase, Prefab extends PrefabBase = PrefabBase> = (spec: Spec, ctx: PrefabParserContext) => Promise<Prefab> | Prefab;
 export type PrefabParserMap<Spec extends PrefabSpecBase, Prefab extends PrefabBase> = Record<string, PrefabParser<Spec, Prefab>>;
-export declare class BasePrefabBucket<M extends PrefabMode = PrefabMode, Spec extends PrefabSpecBase = PrefabSpecBase, Prefab extends PrefabBase = PrefabBase, Specs extends Record<string, Spec> = {}> {
+export declare class BasePrefabBucket<M extends PrefabMode = PrefabMode, Spec extends PrefabSpecBase = PrefabSpecBase, Prefab extends PrefabBase = PrefabBase, Specs extends Record<string, Spec> = {}, HB extends string = string> {
     readonly mode: M;
     /** Shared notification channel - see `PrefabBucketEvents`. */
     readonly events: EventSystem<PrefabBucketEvents>;
@@ -68,26 +72,26 @@ export declare class BasePrefabBucket<M extends PrefabMode = PrefabMode, Spec ex
     protected groups: Map<string, string[]>;
     constructor(mode: M, parsers?: PrefabParserMap<Spec, Prefab>);
     /** Add a single spec. Throws if id is a duplicate, contains '.', or if the bucket is already loaded. */
-    add<const S extends Spec>(spec: S): BasePrefabBucket<M, Spec, Prefab, Specs & {
+    add<const S extends SpecWithHitbox<Spec, HB>>(spec: S): BasePrefabBucket<M, Spec, Prefab, Specs & {
         [K in S['id']]: S;
-    }>;
+    }, HB>;
     /**
      * Internal add that skips the '.' validation. Used by `addGroup` on
      * subclasses to register parts under group-path ids (e.g. `'campfire.logs'`)
      * after the group itself has validated user input.
      */
-    protected addUnchecked<const S extends Spec>(spec: S): BasePrefabBucket<M, Spec, Prefab, Specs & {
+    protected addUnchecked<const S extends SpecWithHitbox<Spec, HB>>(spec: S): BasePrefabBucket<M, Spec, Prefab, Specs & {
         [K in S['id']]: S;
-    }>;
+    }, HB>;
     /**
      * Add multiple specs. Validates the whole batch (ids unique, not loaded) before
      * committing, so the bucket never lands in a half-applied state.
      */
-    addAll<const Ss extends readonly Spec[]>(specs: Ss): BasePrefabBucket<M, Spec, Prefab, Specs & {
+    addAll<const Ss extends readonly SpecWithHitbox<Spec, HB>[]>(specs: Ss): BasePrefabBucket<M, Spec, Prefab, Specs & {
         [K in Ss[number]['id']]: Extract<Ss[number], {
             id: K;
         }>;
-    }>;
+    }, HB>;
     /** Load all pending specs in parallel. Idempotent if already loaded. */
     load(): Promise<void>;
     /**

package/dist/types/renderer/prefab-bucket/specs.d.ts

@@ -42,6 +42,7 @@ export interface GltfSpec {
     readonly freezeAnimations?: boolean;
     /** Optional user-defined sidecar data (scale, speed, gameplay hints, etc). */
     readonly metadata?: Record<string, unknown>;
+    readonly hitbox?: string;
 }
 export interface GridSpec {
     readonly type: 'grid';
@@ -52,6 +53,7 @@ export interface GridSpec {
     readonly lineWidth: number;
     /** Optional user-defined sidecar data (scale, speed, gameplay hints, etc). */
     readonly metadata?: Record<string, unknown>;
+    readonly hitbox?: string;
 }
 /** Unit cube prefab centered at origin. Use the instance's `scale` to size it. */
 export interface CubeSpec {
@@ -60,6 +62,7 @@ export interface CubeSpec {
     /** Edge length. Defaults to 1. */
     readonly size?: number;
     readonly metadata?: Record<string, unknown>;
+    readonly hitbox?: string;
 }
 /** Local transform offset applied to a part inside a composite/group at spawn time. */
 export interface PartOffset {
@@ -80,6 +83,7 @@ export interface CompositeSpec {
         readonly offset?: PartOffset;
     }[];
     readonly metadata?: Record<string, unknown>;
+    readonly hitbox?: string;
 }
 export type Prefab3DSpec = GltfSpec | GridSpec | CubeSpec | CompositeSpec;
 /**
@@ -126,6 +130,7 @@ type GltfPrefabBase<S extends GltfSpec> = {
     readonly totalVertexCount: number;
     /** Passed through from the spec. */
     readonly metadata: MetadataOf<S>;
+    readonly hitbox?: string;
 };
 /**
  * Animation record/list fields, narrowed by what the spec declared:
@@ -161,12 +166,14 @@ export interface GridPrefab<S extends GridSpec = GridSpec> {
     readonly step: number;
     readonly lineWidth: number;
     readonly metadata: MetadataOf<S>;
+    readonly hitbox?: string;
 }
 export interface CubePrefab<S extends CubeSpec = CubeSpec> {
     readonly type: 'cube';
     readonly id: S['id'];
     readonly size: number;
     readonly metadata: MetadataOf<S>;
+    readonly hitbox?: string;
 }
 export interface CompositePrefab<S extends CompositeSpec = CompositeSpec> {
     readonly type: 'composite';
@@ -176,6 +183,7 @@ export interface CompositePrefab<S extends CompositeSpec = CompositeSpec> {
         readonly offset?: PartOffset;
     }[];
     readonly metadata: MetadataOf<S>;
+    readonly hitbox?: string;
 }
 export type Prefab3D = GltfPrefab | GridPrefab | CubePrefab | CompositePrefab;
 export interface SpritesheetSpec {
@@ -188,6 +196,7 @@ export interface SpritesheetSpec {
     /** URL to a texture-packer JSON file. Mutually exclusive with frameWidth/frameHeight. */
     readonly data?: string;
     readonly metadata?: Record<string, unknown>;
+    readonly hitbox?: string;
 }
 export type Prefab2DSpec = SpritesheetSpec;
 export interface SpritesheetPrefab<S extends SpritesheetSpec = SpritesheetSpec> {
@@ -198,6 +207,7 @@ export interface SpritesheetPrefab<S extends SpritesheetSpec = SpritesheetSpec>
     readonly width: number;
     readonly height: number;
     readonly metadata: MetadataOf<S>;
+    readonly hitbox?: string;
 }
 export type Prefab2D = SpritesheetPrefab;
 /**

package/dist/types/renderer/raycast/index.d.ts

@@ -0,0 +1 @@
+export * from './raycast';

package/dist/types/renderer/raycast/raycast.d.ts

@@ -0,0 +1,24 @@
+import type { InputSnapshot } from '../../core/input/types';
+export interface RaycastHit<H, Point extends readonly number[] = readonly number[]> {
+    handle: H;
+    distance: number;
+    point: Point;
+    /** Name of the hitbox part struck, or `null` for a default-bound (box/quad) hit. */
+    part: string | null;
+}
+export interface RaycastOptions<H> {
+    filter?: (handle: H) => boolean;
+    maxDistance?: number;
+}
+export declare abstract class Raycast<H, Point extends readonly number[] = readonly number[]> {
+    abstract update(input: InputSnapshot): void;
+    abstract hit(opts?: RaycastOptions<H>): RaycastHit<H, Point> | null;
+    abstract hitAll(opts?: RaycastOptions<H>): readonly RaycastHit<H, Point>[];
+    abstract memo(opts: RaycastOptions<H>): RaycastMemo<H, Point>;
+    abstract clearMemos(): void;
+}
+export declare abstract class RaycastMemo<H, Point extends readonly number[] = readonly number[]> {
+    abstract readonly hits: readonly RaycastHit<H, Point>[];
+    abstract readonly first: RaycastHit<H, Point> | null;
+    abstract dispose(): void;
+}

package/dist/types/renderer/types.d.ts

@@ -78,6 +78,7 @@ export interface SpriteUV {
     maxY: number;
 }
 export interface SpriteHandle {
+    readonly id: number;
     readonly slot: number;
     x: number;
     y: number;