rn-gamekit 0.1.0 → 0.2.1

package/lib/typescript/src/camera2d/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Camera2D public values (T12.1).
+ *
+ * A camera is immutable plain data: where the view is centered in world
+ * space, how much it zooms, and how it rotates. It carries no Skia
+ * matrices, no shared values, no viewport dimensions — presentation and
+ * conversion derive everything from this value plus the authored logical
+ * view.
+ */
+import type { Point2D } from '../geometry/types.js';
+/** The authored 2D camera value. */
+export interface Camera2D {
+    /** World-space point the camera looks at. */
+    readonly center: Point2D;
+    /** Finite uniform zoom, greater than zero. */
+    readonly zoom: number;
+    /** Rotation in radians, positive per the Skia coordinate convention. */
+    readonly rotationRadians: number;
+}
+/**
+ * A presented camera with an explicit cut signal.
+ *
+ * `cutId` increases monotonically across the lifetime of a camera binding.
+ * A changed `cutId` means the previous camera is unrelated: presentation
+ * snaps instead of interpolating (scene transitions, session replacement,
+ * binding-generation changes, explicit teleports, invalid prior data).
+ */
+export interface CameraCut2D {
+    /** The camera to present. */
+    readonly camera: Camera2D;
+    /** Monotonic cut signal; a new value disables interpolation. */
+    readonly cutId: number;
+}
+/** Per-axis follow enablement. Both default to true. */
+export interface CameraFollowAxisOptions2D {
+    /** Follow on the horizontal axis. */
+    readonly x?: boolean;
+    /** Follow on the vertical axis. */
+    readonly y?: boolean;
+}
+/** Options for `followCamera2D`. */
+export interface FollowCamera2DOptions2D {
+    /**
+     * Axis-aligned dead zone in world units, centered on the camera center.
+     * A target inside the zone leaves the camera untouched.
+     */
+    readonly deadZone?: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    /** Per-axis follow enablement. */
+    readonly perAxis?: CameraFollowAxisOptions2D;
+    /**
+     * Damping half-life in seconds: after this many seconds the remaining
+     * follow distance halves. Requires `deltaSeconds` on the call.
+     */
+    readonly dampingHalfLifeSeconds?: number;
+}
+/** Options for `sampleCameraShake2D`. */
+export interface CameraShakeOptions2D {
+    /** Deterministic seed; equal seeds produce equal offsets. */
+    readonly seed: number;
+    /** Elapsed simulation time in seconds since the shake began. */
+    readonly elapsedSeconds: number;
+    /** Shake duration in seconds; the base camera returns exactly at end. */
+    readonly durationSeconds: number;
+    /** Peak offset magnitude in world units. */
+    readonly amplitude: number;
+    /** Angular frequency in radians per second (defaults to 2π). */
+    readonly frequency?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/camera2d/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/camera2d/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AAEjD,oCAAoC;AACpC,MAAM,WAAW,QAAQ;IACvB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,6BAA6B;IAC7B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,wDAAwD;AACxD,MAAM,WAAW,yBAAyB;IACxC,qCAAqC;IACrC,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;IACrB,mCAAmC;IACnC,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,oCAAoC;AACpC,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAChH,kCAAkC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,yBAAyB,CAAC;IAC7C;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;CAC1C;AAED,yCAAyC;AACzC,MAAM,WAAW,oBAAoB;IACnC,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B"}

package/lib/typescript/src/camera2d/validation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Camera2D validation (T12.1, T12-F6).
+ *
+ * Reuses the Task 11 structured `GeometryError` codes so failures identify
+ * the operation and the invalid field. Validation happens at public
+ * operation boundaries; values are never coerced. Outer shapes are checked
+ * BEFORE field dereferencing, so null, arrays, and missing nested objects
+ * produce structured errors instead of incidental `TypeError`s.
+ */
+import type { Aabb2D, Point2D } from '../geometry/types.js';
+import type { Camera2D } from './types.js';
+/** Assert the outer shape of a camera before dereferencing fields. */
+export declare function assertCameraShape(camera: unknown, field: string): asserts camera is Camera2D;
+/** Assert a valid camera value (shape + fields). */
+export declare function assertValidCamera2D(camera: Camera2D): void;
+/** Assert a finite point (shape first). */
+export declare function assertFinitePoint2D(point: unknown, field: string): asserts point is Point2D;
+/** Assert a valid logical view rect (shape + finite positive size). */
+export declare function assertValidLogicalView(view: unknown): asserts view is Aabb2D;
+/** Assert a nonnegative padding. */
+export declare function assertNonnegativePadding(padding: number): void;
+/**
+ * Strict full-camera clone (T12-SF3): validates a COMPLETE runtime camera —
+ * every required field present and finite — and returns an owned frozen
+ * copy. Unlike `createCamera2D` (which fills partial authored options with
+ * identity defaults), a missing field is rejected. Used at publication
+ * boundaries where a partial value must never be silently completed.
+ */
+export declare function cloneValidCamera2D(camera: unknown, field?: string): Camera2D;
+//# sourceMappingURL=validation.d.ts.map

package/lib/typescript/src/camera2d/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/camera2d/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAS,CAAC;AAMxC,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,QAAQ,CAe5F;AAED,oDAAoD;AACpD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAa1D;AAED,2CAA2C;AAC3C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAW3F;AAED,uEAAuE;AACvE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,IAAI,MAAM,CAoB5E;AAED,oCAAoC;AACpC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,SAAW,GAAG,QAAQ,CAyB9E"}

package/lib/typescript/src/camera2d/visibility.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Camera2D visibility (T12.6).
+ *
+ * Presentation-only culling: computes what the camera can see and filters
+ * render records without changing simulation. An off-screen entity keeps
+ * simulating, colliding, and re-entering view. For rotated cameras the
+ * broad test uses the conservative visible AABB (a superset of the actual
+ * view polygon), so false positives are possible but false negatives are
+ * not — a visible object can never pop out.
+ */
+import type { Aabb2D, Circle2D, Point2D } from '../geometry/types.js';
+import type { Camera2D } from './types.js';
+/** A shape queryable against the camera view. */
+export type CameraViewShape2D = {
+    readonly kind: 'aabb';
+    readonly bounds: Aabb2D;
+} | {
+    readonly kind: 'circle';
+    readonly circle: Circle2D;
+} | {
+    readonly kind: 'point';
+    readonly point: Point2D;
+};
+/** The visible world bounds expanded by an optional padding. */
+export declare function paddedCameraBounds2D(camera: Camera2D, logicalView: Aabb2D, padding?: number): Aabb2D;
+/**
+ * Whether a shape intersects the camera's visible region.
+ *
+ * The test is conservative: it uses the visible world AABB (exact for
+ * unrotated cameras, a superset for rotated ones). `padding` extends the
+ * region in world units for sprites and effects that draw outside their
+ * logical bounds.
+ */
+export declare function intersectsCameraView2D(shape: CameraViewShape2D, camera: Camera2D, logicalView: Aabb2D, padding?: number): boolean;
+/**
+ * Filter indexed render records, preserving stable order.
+ *
+ * Returns a frozen copy containing only the records whose world bounds
+ * intersect the visible region (plus `padding`). Off-screen records keep
+ * their identity and order in the caller's array; nothing here mutates
+ * them or changes simulation.
+ */
+export declare function filterCameraVisible2D<T extends {
+    readonly id: string;
+    readonly bounds: Aabb2D;
+}>(items: readonly T[], camera: Camera2D, logicalView: Aabb2D, padding?: number): readonly T[];
+//# sourceMappingURL=visibility.d.ts.map

package/lib/typescript/src/camera2d/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../../src/camera2d/visibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AAInE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAS,CAAC;AA6FxC,iDAAiD;AACjD,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAExD,gEAAgE;AAChE,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,MAAM,EACnB,OAAO,SAAI,GACV,MAAM,CAWR;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,MAAM,EACnB,OAAO,SAAI,GACV,OAAO,CAWT;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC9F,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,MAAM,EACnB,OAAO,SAAI,GACV,SAAS,CAAC,EAAE,CAUd"}

package/lib/typescript/src/camera2d.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Subpath entry for `rn-gamekit/camera2d`.
+ *
+ * Headless camera math — no React hooks, Skia, or native peers.
+ */
+export * from './camera2d/index.js';
+//# sourceMappingURL=camera2d.d.ts.map

package/lib/typescript/src/camera2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera2d.d.ts","sourceRoot":"","sources":["../../../src/camera2d.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,qBAAkB,CAAC"}

package/lib/typescript/src/collision2d/colliders.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Attachable collider records and placement (T11.4).
+ *
+ * A `LocalCollider2D` is immutable local-space data: its `offset` and shape
+ * dimensions are relative to an authored object position. `placeCollider2D`
+ * is the ONLY local -> world path; world colliders feed broad-phase,
+ * collider-pair, and debug operations. Placement preserves filter, sensor,
+ * identifier, and author metadata and never mutates the source.
+ *
+ * Translation only: a rectangle stays axis-aligned and a circle stays a
+ * circle. There is no general transform, and rendering never owns gameplay
+ * collision state.
+ */
+import type { Aabb2D, Circle2D, Point2D, Vector2D } from '../geometry/types.js';
+import type { CollisionFilter2D } from './filters.js';
+import { type CollisionHit2D } from './manifolds.js';
+/** Shared collider metadata. */
+export interface ColliderMetadata2D {
+    /** Optional collision filter; absent means eligible with everything. */
+    readonly filter?: CollisionFilter2D;
+    /** True marks detection intent; never changes geometry results. */
+    readonly sensor?: boolean;
+    /** Stable user/entity identifier, independent of array indexes. */
+    readonly id?: string;
+}
+/** A local-space AABB collider. */
+export interface LocalAabbCollider2D extends ColliderMetadata2D {
+    readonly space: 'local';
+    readonly shape: 'aabb';
+    /** Offset of the AABB's top-left corner from the authored object position. */
+    readonly offset: Vector2D;
+    /** Local width in logical world units. */
+    readonly width: number;
+    /** Local height in logical world units. */
+    readonly height: number;
+}
+/** A local-space circle collider. */
+export interface LocalCircleCollider2D extends ColliderMetadata2D {
+    readonly space: 'local';
+    readonly shape: 'circle';
+    /** Offset of the circle's center from the authored object position. */
+    readonly offset: Vector2D;
+    /** Local radius in logical world units. */
+    readonly radius: number;
+}
+/** A collider definition in the authored object's local space. */
+export type LocalCollider2D = LocalAabbCollider2D | LocalCircleCollider2D;
+/** A world-space AABB collider (already placed). */
+export interface WorldAabbCollider2D extends ColliderMetadata2D {
+    readonly space: 'world';
+    readonly shape: 'aabb';
+    /** World top-left corner. */
+    readonly x: number;
+    /** World top-left corner. */
+    readonly y: number;
+    /** World width. */
+    readonly width: number;
+    /** World height. */
+    readonly height: number;
+}
+/** A world-space circle collider (already placed). */
+export interface WorldCircleCollider2D extends ColliderMetadata2D {
+    readonly space: 'world';
+    readonly shape: 'circle';
+    /** World center x. */
+    readonly x: number;
+    /** World center y. */
+    readonly y: number;
+    /** World radius. */
+    readonly radius: number;
+}
+/** A collider placed in world space. */
+export type WorldCollider2D = WorldAabbCollider2D | WorldCircleCollider2D;
+/** Options for the beginner rectangle collider constructor. */
+export interface RectangleCollider2DOptions {
+    /** Offset of the top-left corner from the object position. */
+    readonly offset: Vector2D;
+    /** Local width. */
+    readonly width: number;
+    /** Local height. */
+    readonly height: number;
+    readonly filter?: CollisionFilter2D;
+    readonly sensor?: boolean;
+    readonly id?: string;
+}
+/** Options for the beginner circle collider constructor. */
+export interface CircleCollider2DOptions {
+    /** Offset of the center from the object position. */
+    readonly offset: Vector2D;
+    /** Local radius. */
+    readonly radius: number;
+    readonly filter?: CollisionFilter2D;
+    readonly sensor?: boolean;
+    readonly id?: string;
+}
+/** Create an immutable local AABB collider. */
+export declare function rectangleCollider2D(options: RectangleCollider2DOptions): LocalAabbCollider2D;
+/** Create an immutable local circle collider. */
+export declare function circleCollider2D(options: CircleCollider2DOptions): LocalCircleCollider2D;
+/**
+ * Place a local collider at an authored object position, returning an
+ * immutable world-space collider. Rejects local colliders at compile time.
+ */
+export declare function placeCollider2D(local: LocalCollider2D, position: Point2D): WorldCollider2D;
+/** World-space AABB view of a collider (for broad-phase bounds). */
+export declare function worldColliderBounds2D(world: WorldCollider2D): Aabb2D;
+/** World-space circle view of a collider (for narrow-phase pairs). */
+export declare function worldColliderCircle2D(world: WorldCollider2D): Circle2D | undefined;
+/**
+ * Narrow-phase contact between two placed world colliders.
+ *
+ * Filters are normalized first: an absent filter behaves exactly as
+ * `ALL_FILTER2D`, so `NONE_FILTER2D` on either side truly collides with
+ * nothing. The dispatch preserves the public argument order: the returned
+ * normal always moves the FIRST argument out of the SECOND, including for
+ * mixed AABB/circle pairs (the AABB-first wrapper inverts only the
+ * circle-first manifold normal, keeping depth and the world contact point).
+ */
+export declare function collideWorldColliders2D(first: WorldCollider2D, second: WorldCollider2D): CollisionHit2D | undefined;
+//# sourceMappingURL=colliders.d.ts.map

package/lib/typescript/src/collision2d/colliders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colliders.d.ts","sourceRoot":"","sources":["../../../../src/collision2d/colliders.ts"],"names":[],"mappings":"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"}

package/lib/typescript/src/collision2d/debug.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Headless debug projections (T11.6).
+ *
+ * Immutable debug primitives a renderer can draw without importing Skia
+ * into the collision module. Colors and labels are optional presentation
+ * metadata, never gameplay semantics. Production collision results never
+ * allocate debug data; projection is opt-in.
+ */
+import type { Point2D, Vector2D } from '../geometry/types.js';
+import type { CollisionHit2D } from './manifolds.js';
+import type { WorldCollider2D } from './colliders.js';
+/** Optional presentation metadata. */
+export interface DebugStyle2D {
+    /** Optional presentation color (renderer-specific encoding). */
+    readonly color?: string;
+    /** Optional author label (collider names, for example). */
+    readonly label?: string;
+}
+/** Debug AABB. */
+export interface DebugAabb2D extends DebugStyle2D {
+    readonly kind: 'aabb';
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** Debug circle. */
+export interface DebugCircle2D extends DebugStyle2D {
+    readonly kind: 'circle';
+    readonly x: number;
+    readonly y: number;
+    readonly radius: number;
+}
+/** Debug segment (sweep paths, rays). */
+export interface DebugSegment2D extends DebugStyle2D {
+    readonly kind: 'segment';
+    readonly start: Point2D;
+    readonly end: Point2D;
+}
+/** Debug point (contact points). */
+export interface DebugPoint2D extends DebugStyle2D {
+    readonly kind: 'point';
+    readonly x: number;
+    readonly y: number;
+}
+/** Debug vector (normals), drawn from `(x, y)` along `(dx, dy)`. */
+export interface DebugVector2D extends DebugStyle2D {
+    readonly kind: 'vector';
+    readonly x: number;
+    readonly y: number;
+    readonly dx: number;
+    readonly dy: number;
+}
+/** Any headless debug primitive. */
+export type DebugPrimitive2D = DebugAabb2D | DebugCircle2D | DebugSegment2D | DebugPoint2D | DebugVector2D;
+/** Project a world collider into a debug primitive, preserving its id. */
+export declare function projectWorldCollider2D(world: WorldCollider2D): DebugAabb2D | DebugCircle2D;
+/** Project a contact hit into its contact point and normal arrow. */
+export declare function projectHit2D(hit: CollisionHit2D): {
+    readonly point: DebugPoint2D;
+    readonly normal: DebugVector2D;
+};
+/** Project a sweep path (start to end of the swept reference point). */
+export declare function projectSweepPath2D(start: Point2D, end: Point2D, label?: string): DebugSegment2D;
+/** Project a plain vector arrow (for example a velocity). */
+export declare function projectVector2D(origin: Point2D, vector: Vector2D, label?: string): DebugVector2D;
+//# sourceMappingURL=debug.d.ts.map

package/lib/typescript/src/collision2d/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../../src/collision2d/debug.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAmB,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAa,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAa,CAAC;AAEnD,sCAAsC;AACtC,MAAM,WAAW,YAAY;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,kBAAkB;AAClB,MAAM,WAAW,WAAY,SAAQ,YAAY;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,oBAAoB;AACpB,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,yCAAyC;AACzC,MAAM,WAAW,cAAe,SAAQ,YAAY;IAClD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;CACvB;AAED,oCAAoC;AACpC,MAAM,WAAW,YAAa,SAAQ,YAAY;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,oEAAoE;AACpE,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,oCAAoC;AACpC,MAAM,MAAM,gBAAgB,GACxB,WAAW,GACX,aAAa,GACb,cAAc,GACd,YAAY,GACZ,aAAa,CAAC;AAElB,0EAA0E;AAC1E,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,GAAG,WAAW,GAAG,aAAa,CAmB1F;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,GAAG,EAAE,cAAc,GAAG;IACjD,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;CAChC,CAWA;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,cAAc,CAS/F;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAWhG"}

package/lib/typescript/src/collision2d/filters.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Collision filters (T11.4).
+ *
+ * Symmetric category/mask filtering with unsigned 32-bit bit sets,
+ * following the Box2D convention: two colliders are eligible only when each
+ * category is included by the other mask. No bit positions are reserved.
+ */
+import type { Vector2D } from '../geometry/types.js';
+/** Two explicit unsigned 32-bit bit sets for collision eligibility. */
+export interface CollisionFilter2D {
+    /** The bits this collider belongs to. */
+    readonly categoryBits: number;
+    /** The category bits this collider can collide with. */
+    readonly maskBits: number;
+}
+/**
+ * True when the two filters allow a collision (symmetric check).
+ *
+ * Invalid (non-unsigned-32-bit) values throw `GeometryError` before any
+ * comparison; `false` never implies malformed input.
+ */
+export declare function canCollide2D(first: CollisionFilter2D, second: CollisionFilter2D): boolean;
+/** A collider without a filter: eligible with everything. */
+export declare const ALL_FILTER2D: CollisionFilter2D;
+/** A collider that collides with nothing. */
+export declare const NONE_FILTER2D: CollisionFilter2D;
+export type { Vector2D };
+//# sourceMappingURL=filters.d.ts.map

package/lib/typescript/src/collision2d/filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../../../src/collision2d/filters.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAmB,CAAC;AAGlD,uEAAuE;AACvE,MAAM,WAAW,iBAAiB;IAChC,yCAAyC;IACzC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CASzF;AAED,6DAA6D;AAC7D,eAAO,MAAM,YAAY,EAAE,iBAGzB,CAAC;AAEH,6CAA6C;AAC7C,eAAO,MAAM,aAAa,EAAE,iBAG1B,CAAC;AAEH,YAAY,EAAE,QAAQ,EAAE,CAAC"}

package/lib/typescript/src/collision2d/index.d.ts

@@ -0,0 +1,17 @@
+export type { CollisionHit2D } from './manifolds.js';
+export { RESOLUTION_TOLERANCE } from './manifolds.js';
+export { collideAabbAabb2D, collideCircleAabb2D, collideCircleCircle2D, } from './manifolds.js';
+export { closestPointOnAabb2D, intersectsAabbAabb2D, intersectsCircleAabb2D, intersectsCircleCircle2D, pointInAabb2D, pointInCircle2D, } from './intersections.js';
+export type { SegmentHit2D } from './segments.js';
+export { intersectSegmentAabb2D, intersectSegmentCircle2D, } from './segments.js';
+export type { SweepAabbAabb2DOptions, SweepCircleAabb2DOptions, SweepHit2D, } from './sweeps.js';
+export { sweepAabbAabb2D, sweepCircleAabb2D, } from './sweeps.js';
+export type { CollisionFilter2D } from './filters.js';
+export { ALL_FILTER2D, canCollide2D, NONE_FILTER2D, } from './filters.js';
+export type { CircleCollider2DOptions, ColliderMetadata2D, LocalAabbCollider2D, LocalCircleCollider2D, LocalCollider2D, RectangleCollider2DOptions, WorldAabbCollider2D, WorldCircleCollider2D, WorldCollider2D, } from './colliders.js';
+export { circleCollider2D, collideWorldColliders2D, placeCollider2D, rectangleCollider2D, worldColliderBounds2D, worldColliderCircle2D, } from './colliders.js';
+export type { BuildSpatialHash2DOptions, SpatialHashIndex2D, SpatialHashItem2D } from './spatialHash.js';
+export { buildSpatialHash2D, querySpatialHash2D, } from './spatialHash.js';
+export type { DebugAabb2D, DebugCircle2D, DebugPoint2D, DebugPrimitive2D, DebugSegment2D, DebugStyle2D, DebugVector2D, } from './debug.js';
+export { projectHit2D, projectSweepPath2D, projectVector2D, projectWorldCollider2D, } from './debug.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/collision2d/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/collision2d/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAa,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAa,CAAC;AACnD,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,gBAAa,CAAC;AACrB,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,EACxB,aAAa,EACb,eAAe,GAChB,MAAM,oBAAiB,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,MAAM,eAAY,CAAC;AAC/C,OAAO,EACL,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,eAAY,CAAC;AACpB,YAAY,EACV,sBAAsB,EACtB,wBAAwB,EACxB,UAAU,GACX,MAAM,aAAU,CAAC;AAClB,OAAO,EACL,eAAe,EACf,iBAAiB,GAClB,MAAM,aAAU,CAAC;AAClB,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAW,CAAC;AACnD,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,aAAa,GACd,MAAM,cAAW,CAAC;AACnB,YAAY,EACV,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,GAChB,MAAM,gBAAa,CAAC;AACrB,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,gBAAa,CAAC;AACrB,YAAY,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,kBAAe,CAAC;AACtG,OAAO,EACL,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,kBAAe,CAAC;AACvB,YAAY,EACV,WAAW,EACX,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,aAAa,GACd,MAAM,YAAS,CAAC;AACjB,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,sBAAsB,GACvB,MAAM,YAAS,CAAC"}

package/lib/typescript/src/collision2d/intersections.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Static intersection predicates (T11.2).
+ *
+ * Boundary contact counts as intersection. Invalid geometry throws
+ * `GeometryError`; `false` means normal domain absence. All predicates
+ * allocate nothing.
+ */
+import type { Aabb2D, Circle2D, Point2D } from '../geometry/types.js';
+/** True when `point` lies in or on `aabb` (boundary inclusive). */
+export declare function pointInAabb2D(point: Point2D, aabb: Aabb2D): boolean;
+/** True when `point` lies in or on `circle` (boundary inclusive). */
+export declare function pointInCircle2D(point: Point2D, circle: Circle2D): boolean;
+/** True when the two AABBs intersect or touch. */
+export declare function intersectsAabbAabb2D(first: Aabb2D, second: Aabb2D): boolean;
+/** True when the two circles intersect or touch. */
+export declare function intersectsCircleCircle2D(first: Circle2D, second: Circle2D): boolean;
+/** True when the circle intersects or touches the AABB. */
+export declare function intersectsCircleAabb2D(circle: Circle2D, aabb: Aabb2D): boolean;
+/** Closest point on the AABB to the circle center (shared by manifold code). */
+export declare function closestPointOnAabb2D(point: Point2D, aabb: Aabb2D): {
+    readonly x: number;
+    readonly y: number;
+};
+//# sourceMappingURL=intersections.d.ts.map

package/lib/typescript/src/collision2d/intersections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersections.d.ts","sourceRoot":"","sources":["../../../../src/collision2d/intersections.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AAOnE,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CASnE;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAMzE;AAED,kDAAkD;AAClD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAS3E;AAED,oDAAoD;AACpD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAOnF;AAED,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAQ9E;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,GACX;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAK5C"}

package/lib/typescript/src/collision2d/manifolds.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Contact manifolds (T11.2).
+ *
+ * A `CollisionHit2D` reports geometry only: the normal that moves the FIRST
+ * argument out of the SECOND, the nonnegative penetration depth, and a
+ * stable contact point. Applying `first += normal * depth` resolves an
+ * ordinary overlap within documented floating-point tolerance. Misses
+ * return `undefined` and allocate nothing.
+ *
+ * Conventions (locked in T11.0):
+ * - Boundary contact counts as intersection and may return a zero-depth hit.
+ * - Circle-AABB: the contact point is the closest point on the AABB to the
+ *   circle center; when the center is inside the AABB, the minimum
+ *   penetration face wins with ties in the order left, top, right, bottom.
+ * - Circle-circle: the contact point is on the first circle's boundary
+ *   toward the second; coincident centers use the fallback normal `(0, 1)`
+ *   (straight up the positive-y axis) with full overlap depth `r1 + r2`.
+ * - AABB-AABB: the contact point is the center of the overlap rectangle;
+ *   exact corner ties use the normal `(0, 1)`.
+ */
+import type { Aabb2D, Circle2D, Point2D, Vector2D } from '../geometry/types.js';
+/** One contact between two shapes, in the first shape's local resolution. */
+export interface CollisionHit2D {
+    /** Unit normal moving the first argument out of the second. */
+    readonly normal: Vector2D;
+    /** Nonnegative penetration depth in logical world units. */
+    readonly depth: number;
+    /** Stable contact point in world coordinates. */
+    readonly point: Point2D;
+}
+/** Resolution tolerance used by tests: relative to the shape size. */
+export declare const RESOLUTION_TOLERANCE = 1e-9;
+/** AABB-AABB contact manifold. `undefined` when the shapes do not touch. */
+export declare function collideAabbAabb2D(first: Aabb2D, second: Aabb2D): CollisionHit2D | undefined;
+/** Circle-circle contact manifold. `undefined` when the circles do not touch. */
+export declare function collideCircleCircle2D(first: Circle2D, second: Circle2D): CollisionHit2D | undefined;
+/** Circle-AABB contact manifold. `undefined` when they do not touch. */
+export declare function collideCircleAabb2D(circle: Circle2D, aabb: Aabb2D): CollisionHit2D | undefined;
+//# sourceMappingURL=manifolds.d.ts.map

package/lib/typescript/src/collision2d/manifolds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifolds.d.ts","sourceRoot":"","sources":["../../../../src/collision2d/manifolds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAmB,CAAC;AAO7E,6EAA6E;AAC7E,MAAM,WAAW,cAAc;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,sEAAsE;AACtE,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CA+C3F;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,QAAQ,GACf,cAAc,GAAG,SAAS,CAqC5B;AAED,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAwD9F"}

package/lib/typescript/src/collision2d/segments.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Segment queries (T11.3).
+ *
+ * Return the earliest crossing of a directed segment with a shape, with
+ * `time` in `[0, 1]`. A segment starting inside a shape returns `time: 0`
+ * with the deterministic nearest-face normal (same tie rule as the
+ * manifolds: left, top, right, bottom for AABBs; the outward radial
+ * direction for circles with the `(0, 1)` fallback at the center).
+ */
+import type { Aabb2D, Circle2D, Point2D, Segment2D, Vector2D } from '../geometry/types.js';
+/** Earliest segment crossing of a shape. */
+export interface SegmentHit2D {
+    /** Normalized crossing time in `[0, 1]`. */
+    readonly time: number;
+    /** Unit normal at the crossed boundary (nearest-face rule inside). */
+    readonly normal: Vector2D;
+    /** Crossing point in world coordinates. */
+    readonly point: Point2D;
+}
+/** Earliest crossing of a segment with an AABB (slab method). */
+export declare function intersectSegmentAabb2D(segment: Segment2D, aabb: Aabb2D): SegmentHit2D | undefined;
+/** Earliest crossing of a segment with a circle. */
+export declare function intersectSegmentCircle2D(segment: Segment2D, circle: Circle2D): SegmentHit2D | undefined;
+//# sourceMappingURL=segments.d.ts.map

package/lib/typescript/src/collision2d/segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segments.d.ts","sourceRoot":"","sources":["../../../../src/collision2d/segments.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,sBAAmB,CAAC;AAQxF,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC3B,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,iEAAiE;AACjE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAgEjG;AA0BD,oDAAoD;AACpD,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,EAClB,MAAM,EAAE,QAAQ,GACf,YAAY,GAAG,SAAS,CAqD1B"}

package/lib/typescript/src/collision2d/spatialHash.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Deterministic spatial hash broad phase (T11.5).
+ *
+ * `buildSpatialHash2D` validates and freezes a plain immutable index value;
+ * the per-cell buckets live in an internal WeakMap so callers can never
+ * mutate or depend on them. `querySpatialHash2D` visits only the query's
+ * cells and returns candidate ids deduplicated and in original insertion
+ * order. The broad phase is conservative: it returns candidates, never a
+ * narrow-phase collision claim.
+ */
+import type { Aabb2D } from '../geometry/types.js';
+/** One indexed item with a stable identifier and AABB bounds. */
+export interface SpatialHashItem2D {
+    /** Stable identifier; must be unique within one index. */
+    readonly id: string;
+    /** AABB bounds in world coordinates. */
+    readonly bounds: Aabb2D;
+}
+/** A frozen, immutable spatial-hash index. */
+export interface SpatialHashIndex2D {
+    /** Positive finite cell size in world units. */
+    readonly cellSize: number;
+    /** The ordered items, deduplicated by identifier. */
+    readonly items: readonly SpatialHashItem2D[];
+}
+/** Options for building an index. */
+export interface BuildSpatialHash2DOptions {
+    /** Items to index, in the order candidates must be returned. */
+    readonly items: readonly SpatialHashItem2D[];
+    /** Positive finite cell size in world units. */
+    readonly cellSize: number;
+}
+/** Maximum cells an item or query may OCCUPY per axis (bounded execution). */
+export declare const MAX_SPATIAL_HASH_SPAN_CELLS = 1024;
+/**
+ * Maximum cells visited by ONE item insert or ONE query (GS-COLLISION-02).
+ *
+ * The per-axis bound alone permits ~1M cell visits per operation (~38ms
+ * on desktop V8, multiples of that on mobile). The total budget fails
+ * clearly before such spans do any work. Ordinary game spans (a few
+ * hundred cells per axis at most) pass with wide headroom; aggregate build
+ * cost still scales with item count, so prefer an appropriate cell size
+ * and reuse static indexes instead of rebuilding per dynamic body per tick.
+ */
+export declare const MAX_SPATIAL_HASH_TOTAL_CELLS = 65536;
+/** Build a spatial-hash index over the given items. */
+export declare function buildSpatialHash2D(options: BuildSpatialHash2DOptions): SpatialHashIndex2D;
+/** Query candidates whose bounds share a cell with the query bounds. */
+export declare function querySpatialHash2D(index: SpatialHashIndex2D, bounds: Aabb2D): readonly string[];
+//# sourceMappingURL=spatialHash.d.ts.map

package/lib/typescript/src/collision2d/spatialHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatialHash.d.ts","sourceRoot":"","sources":["../../../../src/collision2d/spatialHash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAmB,CAAC;AAMhD,iEAAiE;AACjE,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,8CAA8C;AAC9C,MAAM,WAAW,kBAAkB;IACjC,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC9C;AAED,qCAAqC;AACrC,MAAM,WAAW,yBAAyB;IACxC,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC7C,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,8EAA8E;AAC9E,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAEhD;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAQnD,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAqDzF;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CA6B/F"}