@forgeax/engine-render 0.0.0-dev.8d955ade1c79

package/dist/components/spot-light.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Cone-restricted spot light (KHR_lights_punctual `spot` type).  Casts shadows
+ * by default (castShadow defaults to true) — zero-config spawns project hard
+ * PCF shadows through an independent spot depth atlas.
+ *
+ * `direction` @semantics outgoing -- points FROM light source TO the
+ * scene (consistent with `DirectionalLight`; the shader internally negates
+ * this vector to obtain the L vector for BRDF evaluation:
+ * `let l = normalize(-light.direction)`). Extract owns the single
+ * normalization step for the snapshot; URP and HDRP consume that normalized
+ * value without re-normalizing. `position` source: the companion
+ * `Transform` component on the same entity.
+ *
+ * `innerConeDeg` is the half-angle of the saturated bright region (cone
+ * fully bright at the axis); `outerConeDeg` is the half-angle of the
+ * falloff edge (cone fully dark beyond). Unit is **degrees**;
+ * `outerConeDeg in (innerConeDeg, 90]` (KHR upper bound; spawn-time
+ * validation rejects `outer > 90` and `outer <= inner`). The host-side
+ * extract step converts both to `cos*` before GPU upload so the shader
+ * only sees pre-computed cosines (plan-strategy D-S2 byte freeze; charter
+ * P4 host pre-multiplication parity).
+ *
+ * `color` is linear-space rgb in `[0, 1]` per channel; `intensity` is candela;
+ * `range` is in meters and defaults to `10.0`. Exposure is a camera output
+ * operation and does not change the stored intensity.
+ *
+ * Shadow fields (embedded, aligned with DirectionalLight):
+ *   castShadow    ∈ {true, false}    — shadow opt-out gate (default true)
+ *   mapSize       >= 1               — shadow map resolution per tile (default 2048)
+ *   depthBias                        — shadow acne bias (default 0.005)
+ *   normalBias                       — shadow acne normal offset (default 0.05)
+ *   nearPlane                        — shadow-camera near (default 0.1)
+ *   farPlane                         — shadow-camera far (default 50)
+ *   pcfKernelSize odd >= 1           — PCF kernel width (default 3)
+ *
+ * Atlas capacity is capped at 4 castShadow spot lights by the extract stage;
+ * the 5th light onward keeps direct illumination but shadowAtlasTile = -1
+ * (AC-05: clip is programmatically detectable, light stays visible).
+ *
+ * @example Spawn a single spot light casting shadows (zero-config):
+ *   world.spawn(
+ *     { component: Transform, data: { pos: [0, 5, 0] } },
+ *     { component: SpotLight, data: { direction: [0, -1, 0] } }, // [x, y, z]
+ *   );
+ *
+ * @example Opt out of shadows:
+ *   world.spawn(
+ *     { component: Transform, data: { pos: [0, 5, 0] } },
+ *     { component: SpotLight, data: { direction: [0, -1, 0], castShadow: false } },
+ *   );
+ *
+ * @example Explicit shadow config:
+ *   world.spawn(
+ *     { component: Transform, data: { pos: [0, 5, 0] } },
+ *     { component: SpotLight, data: { direction: [0, -1, 0], depthBias: 0.01, normalBias: 0.08, mapSize: 1024 } },
+ *   );
+ *
+ * @example Minimal spawn -- defaults give neutral white at full strength, range 10m, KHR pi/4 cone:
+ *   world.spawn(
+ *     { component: Transform, data: { pos: [0, 5, 0] } },
+ *     { component: SpotLight, data: { direction: [0, -1, 0] } }, // [x, y, z]
+ *   );
+ *   // resolves to color=[1,1,1], intensity=1, range=10.0,
+ *   // innerConeDeg=0, outerConeDeg=45 (KHR pi/4 equivalent).
+ */
+export declare const SpotLight: import("@forgeax/engine-ecs").Component<"SpotLight", {
+    readonly direction: "array<f32, 3>";
+    readonly color: "array<f32, 3>";
+    readonly intensity: "f32";
+    readonly range: "f32";
+    readonly innerConeDeg: "f32";
+    readonly outerConeDeg: "f32";
+    readonly castShadow: "bool";
+    readonly mapSize: "f32";
+    readonly depthBias: "f32";
+    readonly normalBias: "f32";
+    readonly nearPlane: "f32";
+    readonly farPlane: "f32";
+    readonly pcfKernelSize: "f32";
+}>;
+//# sourceMappingURL=spot-light.d.ts.map

package/dist/components/spot-light.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spot-light.d.ts","sourceRoot":"","sources":["../../src/components/spot-light.ts"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;EAmBpB,CAAC"}

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

@@ -0,0 +1,74 @@
+/**
+ * Per-entity sprite frame-tick clock.
+ *
+ * Schema (6 fields, 1:1 with requirements section 2.3):
+ * - `frameCount: u32` — total frames (>= 1).
+ * - `frameDuration: f32` — seconds per frame (> 0).
+ * - `currentFrame: u32` — live frame index (0..frameCount). Layer-3
+ *   default `0` when omitted at spawn.
+ * - `accumDt: f32` — dt residue carried across ticks. Layer-3 default
+ *   `0` when omitted; lives on the component (not on a system-side
+ *   resource) so the system stays stateless and AI-user setFrame paths
+ *   can reset both `currentFrame` and `accumDt` atomically.
+ * - `regions: array<f32>` — flat per-frame UV rectangles
+ *   `[uMin, vMin, uW, vH]`; runtime invariant
+ *   `regions.length === frameCount * 4` (enforced by the M4 tick system).
+ * - `playbackMode: u32` — numeric encoding of `SpritePlaybackMode`;
+ *   `SPRITE_PLAYBACK_MODE_LOOP = 0` (default) /
+ *   `SPRITE_PLAYBACK_MODE_CLAMP = 1`.
+ *
+ * Pair with `SpriteRegionOverride` (T-11) — the tick system writes the
+ * per-frame UV slice into the override column, which `render-system-
+ * extract` then reads in the sprite bucket branch.
+ *
+ * @example Spawn a 4-frame walk cycle that loops:
+ *   import { MeshFilter, MeshRenderer } from '@forgeax/engine-render';
+ *   import {
+ *     SpriteAnimation, SpriteRegionOverride, SPRITE_PLAYBACK_MODE_LOOP,
+ *   } from '@forgeax/engine-render/authoring';
+ *   import { Transform } from '@forgeax/engine-scene';
+ *   import { HANDLE_QUAD } from '@forgeax/engine-assets-runtime';
+ *
+ *   // 4 frames packed in an atlas, each 64x64 inside a 256x64 row:
+ *   const regions = new Float32Array([
+ *     0.00, 0, 0.25, 1,  // walk-0
+ *     0.25, 0, 0.25, 1,  // walk-1
+ *     0.50, 0, 0.25, 1,  // walk-2
+ *     0.75, 0, 0.25, 1,  // walk-3
+ *   ]);
+ *   world.spawn(
+ *     { component: Transform, data: { pos: [0, 0, 0],
+ *       quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
+ *     { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
+ *     { component: MeshRenderer, data: { materials: [spriteMaterial] } },
+ *     { component: SpriteAnimation,
+ *       data: {
+ *         frameCount: 4,
+ *         frameDuration: 0.1,
+ *         regions,
+ *         playbackMode: SPRITE_PLAYBACK_MODE_LOOP,
+ *       } },
+ *     { component: SpriteRegionOverride,
+ *       data: { region: new Float32Array([0, 0, 0.25, 1]) } },
+ *   );
+ *
+ * @example Manual setFrame — jump to frame 2 atomically:
+ *   world.set(entity, SpriteAnimation,
+ *     { currentFrame: 2, accumDt: 0 }).unwrap();
+ *
+ * Error path (M4 T-23 routes through `SpriteAnimationInvalidError`,
+ * `EcsErrorCode === 'sprite-animation-invalid'`; charter P3):
+ * - `regions.length !== frameCount * 4` -> detail.field = 'regions-length',
+ *   detail carries `regionsLength` + `frameCount`.
+ * - `frameDuration <= 0` -> detail.field = 'frame-duration', detail carries
+ *   `frameDuration`.
+ */
+export declare const SpriteAnimation: import("@forgeax/engine-ecs").Component<"SpriteAnimation", {
+    readonly frameCount: "u32";
+    readonly frameDuration: "f32";
+    readonly currentFrame: "u32";
+    readonly accumDt: "f32";
+    readonly regions: "array<f32>";
+    readonly playbackMode: "u32";
+}>;
+//# sourceMappingURL=sprite-animation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sprite-animation.d.ts","sourceRoot":"","sources":["../../src/components/sprite-animation.ts"],"names":[],"mappings":"AA+FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,eAAO,MAAM,eAAe;;;;;;;EAO1B,CAAC"}

package/dist/components/sprite-instances.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Per-entity 2D instanced-draw primitive (ECS component).
+ *
+ * Carries two variable-length `array<f32>` fields:
+ *   - `transforms` — column-major mat4 per instance (16 f32, stride 16);
+ *   - `regions`    — UV vec4 per instance ([uMin, vMin, uW, vH], 4 f32,
+ *     stride 4).
+ *
+ * The pair share the same instance count; the invariant
+ * `transforms.length / 16 === regions.length / 4` is enforced at the
+ * RenderSystem extract entry (NOT at ECS write paths). The runtime
+ * RenderSystem consumer materialises a fresh `Float32Array` snapshot on
+ * every `world.get(e, SpriteInstances)` access and uploads an interleaved
+ * 80B-per-instance buffer to the GPU in the record stage.
+ *
+ * @example Spawn an entity rendering 10000 instanced sprites:
+ *   const transforms = new Float32Array(10000 * 16);
+ *   const regions    = new Float32Array(10000 * 4);
+ *   // ... fill mat4 columns + [uMin, vMin, uW, vH] ...
+ *   world.spawn(
+ *     { component: MeshFilter,      data: { assetHandle: HANDLE_QUAD } },
+ *     { component: MeshRenderer,    data: { ... } },
+ *     { component: SpriteInstances, data: { transforms, regions } },
+ *   );
+ */
+export declare const SpriteInstances: import("@forgeax/engine-ecs").Component<"SpriteInstances", {
+    readonly transforms: "array<f32>";
+    readonly regions: "array<f32>";
+}>;
+/**
+ * Type-level hint for `data` at the `SpriteInstances` spawn site.
+ *
+ * The runtime ECS column shape for `array<f32>` accepts a `Float32Array`
+ * payload at spawn / set time (the bytes are copied into the BufferPool
+ * slot). Both fields are typed as `Float32Array` so AI-user IDE
+ * autocomplete picks up the typed-array shape and the AC-09 inference
+ * surfaces without `as` casts inside `world.get(e, SpriteInstances)` and
+ * QueryRow access paths.
+ *
+ * @example
+ *   import type { SpriteInstancesData } from '@forgeax/engine-render/authoring';
+ *   const data: SpriteInstancesData = {
+ *     transforms: new Float32Array(N * 16),
+ *     regions:    new Float32Array(N * 4),
+ *   };
+ */
+export type SpriteInstancesData = {
+    readonly transforms: Float32Array;
+    readonly regions: Float32Array;
+};
+//# sourceMappingURL=sprite-instances.d.ts.map

package/dist/components/sprite-instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sprite-instances.d.ts","sourceRoot":"","sources":["../../src/components/sprite-instances.ts"],"names":[],"mappings":"AAgIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,eAAe;;;EAG1B,CAAC;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;CAChC,CAAC"}

package/dist/components/sprite-playback-mode.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Playback mode discriminator literal union (requirements section AC-02 +
+ * section 2.3). Two members for the MVP:
+ *
+ *   `'loop'`  — `currentFrame = (currentFrame + 1) % frameCount`; the
+ *               sprite-animation-tick system wraps the index when
+ *               `accumDt >= frameDuration` (default for hello-sprite-
+ *               atlas demo "100 sprites synchronised walk cycle").
+ *   `'clamp'` — `currentFrame = min(currentFrame + 1, frameCount - 1)`;
+ *               holds the last frame for death / terminator-animation
+ *               style sequences (requirements section 2.5 q8 lock).
+ *
+ * Future modes (`'pingpong'`, reverse playback, arbitrary frame index
+ * jumps) are deferred per requirements OOS-03. The closed union shape
+ * leaves room for additive growth without breaking the u32 enum encoding
+ * (plan-strategy section 2 D-5).
+ */
+export type SpritePlaybackMode = 'loop' | 'clamp';
+/** Numeric encoding of the loop playback mode (schema value for `playbackMode`). */
+export declare const SPRITE_PLAYBACK_MODE_LOOP: 0;
+/** Numeric encoding of the clamp playback mode (schema value for `playbackMode`). */
+export declare const SPRITE_PLAYBACK_MODE_CLAMP: 1;
+/** Grouped authoring values; the numeric ECS encoding stays owner-local. */
+export declare const SpritePlayback: Readonly<{
+    readonly loop: 0;
+    readonly clamp: 1;
+}>;
+/**
+ * Map a `SpriteAnimation.playbackMode` numeric column value to the closed
+ * `SpritePlaybackMode` string-literal union. The defensive fallback mirrors
+ * `cameraProjectionFromF32` / `tonemapFromF32` precedent — a value other
+ * than `SPRITE_PLAYBACK_MODE_CLAMP` (1) maps to `'loop'`, so stale or
+ * uninitialised entities surface a predictable playback shape through the
+ * tick-system query (rather than throwing or returning `undefined`).
+ * Validation of `playbackMode` happens at schema-write time, not here.
+ *
+ * The tick-system in M4 T-23 (`spriteAnimationTickSystem`) consumes the
+ * return value via `switch (mode) { case 'loop': ...; case 'clamp': ... }`
+ * to pick the per-branch frame-advance arithmetic.
+ */
+export declare function spritePlaybackModeFromU32(value: number): SpritePlaybackMode;
+//# sourceMappingURL=sprite-playback-mode.d.ts.map

package/dist/components/sprite-playback-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sprite-playback-mode.d.ts","sourceRoot":"","sources":["../../src/components/sprite-playback-mode.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,OAAO,CAAC;AAElD,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,EAAG,CAAU,CAAC;AAEpD,qFAAqF;AACrF,eAAO,MAAM,0BAA0B,EAAG,CAAU,CAAC;AAErD,4EAA4E;AAC5E,eAAO,MAAM,cAAc;;;EAGhB,CAAC;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAE3E"}

package/dist/components/sprite-region-override.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Per-entity sprite UV region override (sprite-only).
+ *
+ * Carries a fixed-length `Float32Array(4)` of `[uMin, vMin, uW, vH]` that
+ * `render-system-extract` reads in the sprite bucket branch and writes
+ * into `paramSnapshot.region`, replacing the asset-side region for
+ * this entity only (feat-20260625 M3 ablation: the prior per-entity POD
+ * indirection collapsed into the generic paramSchema-driven snapshot).
+ * Opaque buckets ignore this component; the AC-11 grep gate keeps the
+ * producer / consumer separation structural (this file never names the
+ * asset-side sprite discriminant identifier).
+ *
+ * Pair with `SpriteAnimation` to drive the override per frame
+ * (sprite-animation-tick system, M4 T-23). Standalone use (manual region
+ * override without animation) is also supported — set the column once and
+ * the next extract picks up the new value.
+ *
+ * Schema-vocab keyword `'array<f32, 4>'` (D-6) — fixed-length 4 is the
+ * compile-time enforcement axis. `Float32Array` payloads with length !== 4
+ * round-trip fewer / more bytes per the underlying BufferPool slot, but
+ * the slot is sized at schema registration time; AI users keep the
+ * payload exactly four-floats wide.
+ *
+ * @example Spawn a sprite entity that displays the right half of an atlas:
+ *   import { MeshFilter, MeshRenderer } from '@forgeax/engine-render';
+ *   import { SpriteRegionOverride } from '@forgeax/engine-render/authoring';
+ *   import { Transform } from '@forgeax/engine-scene';
+ *   import { HANDLE_QUAD } from '@forgeax/engine-assets-runtime';
+ *
+ *   world.spawn(
+ *     { component: Transform, data: { pos: [0, 0, 0],
+ *       quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
+ *     { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
+ *     { component: MeshRenderer, data: { materials: [spriteMaterial] } },
+ *     { component: SpriteRegionOverride,
+ *       data: { region: new Float32Array([0.5, 0, 0.5, 1]) } },
+ *   );
+ *
+ * @example Update the override at runtime (e.g. flip-frame test):
+ *   world.set(entity, SpriteRegionOverride,
+ *     { region: new Float32Array([0, 0, 1, 1]) }).unwrap();
+ */
+export declare const SpriteRegionOverride: import("@forgeax/engine-ecs").Component<"SpriteRegionOverride", {
+    readonly region: "array<f32, 4>";
+}>;
+//# sourceMappingURL=sprite-region-override.d.ts.map

package/dist/components/sprite-region-override.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sprite-region-override.d.ts","sourceRoot":"","sources":["../../src/components/sprite-region-override.ts"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,oBAAoB;;EAE/B,CAAC"}

package/dist/components/tile-layer.d.ts

@@ -0,0 +1,106 @@
+import { type EcsError, type EntityHandle, type World } from '@forgeax/engine-ecs';
+import type { Result } from '@forgeax/engine-types';
+/**
+ * Closed string-literal union for the TileLayer.sortScope field. AI users
+ * grep `sortScope` and land on this single SSOT type alias; switch
+ * statements over this type are exhaustive without a default arm.
+ *
+ *   - 'layer'    - terrain semantics; whole layer shares one Layer.value
+ *                  bucket and Y-sorts together (chunkIndex is folded into 0).
+ *   - 'per-cell' - object semantics; each derived entity gets its own
+ *                  chunkIndex tiebreak so it can Y-interleave with
+ *                  sprite entities carrying the same Layer.value (e.g. a
+ *                  player sprite riding the same SPRITE_LAYER_VALUE).
+ */
+export type SortScope = 'layer' | 'per-cell';
+/** Compact authoring values for the stored u8 sort-scope field. */
+export declare const TilemapSort: Readonly<{
+    layer: 0;
+    perCell: 1;
+}>;
+/**
+ * Bridge: `SortScope` -> on-disk u8. SSOT for the encoding (`'layer'` -> 0,
+ * `'per-cell'` -> 1). The compile-time exhaustive switch guards against
+ * silent drift if the union ever grows; adding a new literal here without
+ * adding its arm fails typecheck (charter P3 — closed unions never default).
+ */
+export declare function encodeSortScope(scope: SortScope): 0 | 1;
+/**
+ * Bridge: on-disk u8 -> `SortScope`. Defaults to `'layer'` for any value
+ * outside `{0, 1}` (defensive — the column is typed `u8` so out-of-range
+ * values can only appear if a future schema migration loosens the bound;
+ * the default preserves terrain semantics which is the safer of the two).
+ */
+export declare function decodeSortScope(raw: number | undefined): SortScope;
+/**
+ * Public TileLayer field shape (`world.spawn({ component: TileLayer, data:
+ * { ... } })` payload). `sortScope` is the closed string union surfaced to
+ * AI users; the runtime row encodes it as `u8` via `encodeSortScope` at
+ * spawn time so on-disk storage stays compact.
+ *
+ * Treat as the `TileLayer` data SSOT — `defineComponent` schema below
+ * mirrors it field-for-field with the bridge `sortScope: u8` in place of
+ * the union literal.
+ */
+export interface TileLayerData {
+    readonly tiles: Uint32Array;
+    readonly layerOrder?: number;
+    readonly dirty?: number;
+    readonly sortScope?: SortScope;
+}
+/**
+ * TileLayer component (M0 baseline rebuild + round-2 sortScope rename).
+ *
+ * AI users typically spawn a TileLayer + ChildOf pair pointing at an
+ * existing Tilemap entity:
+ *
+ * @example
+ *   const tilesArray = new Uint32Array(cols * rows);
+ *   tilesArray[5 * cols + 7] = 1; // tile id 1 at cell (7, 5)
+ *   world.spawn(
+ *     { component: TileLayer, data: { tiles: tilesArray, layerOrder: 0 } },
+ *     { component: ChildOf,  data: { parent: tilemapEntity } },
+ *   );
+ *
+ * Object-layer variant (Y-interleave with sprite entities):
+ *
+ * > NOTE: schema storage is `u8` (ECS schema does not support
+ * > string-literal-union column constraints; see R-NEW-2). The
+ * > AI-user surface is the closed `SortScope` string union, but
+ * > `world.spawn` requires the numeric encoding — pass through
+ * > `encodeSortScope('per-cell')` rather than the literal string.
+ *
+ * @example
+ *   world.spawn(
+ *     { component: TileLayer, data: {
+ *         tiles: objectTiles,
+ *         layerOrder: 1000,
+ *         sortScope: encodeSortScope('per-cell'),
+ *       } },
+ *     { component: ChildOf, data: { parent: tilemapEntity } },
+ *   );
+ *
+ * Defaults: `layerOrder = 0`, `dirty = 0`, `sortScope = 'layer'` (stored
+ * as `u8 = 0`, i.e. `encodeSortScope('layer')`). `tiles` has no default -
+ * AI users supply the per-cell array at spawn time. To trigger a re-build
+ * after mutating tiles in place, call `markTileLayerDirty(world, layer)`.
+ */
+export declare const TileLayer: import("@forgeax/engine-ecs").Component<"TileLayer", {
+    readonly tiles: "array<u32>";
+    readonly layerOrder: "i32";
+    readonly dirty: "u8";
+    readonly sortScope: "u8";
+}>;
+/**
+ * Mark a TileLayer entity dirty so the next `tilemapChunkExtractSystem`
+ * pass purges and re-spawns its derived per-cell entities. Use this after
+ * mutating `TileLayer.tiles` (e.g. an in-place patch via a column view).
+ *
+ * Returns the underlying ECS write result - on `err` branch the caller
+ * can read `.code` to recover (`'stale-entity'` if the layer was
+ * despawned, `'component-not-present'` if the entity is missing the
+ * TileLayer column; both kebab-case literals are members of the closed
+ * `EcsErrorCode` union).
+ */
+export declare function markTileLayerDirty(world: World, layerEntity: EntityHandle): Result<void, EcsError>;
+//# sourceMappingURL=tile-layer.d.ts.map

package/dist/components/tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-layer.d.ts","sourceRoot":"","sources":["../../src/components/tile-layer.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAmB,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAE,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;AAE7C,mEAAmE;AACnE,eAAO,MAAM,WAAW;;;EAGtB,CAAC;AAEH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,GAAG,CAAC,CAOvD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAElE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,SAAS;;;;;EAKpB,CAAC;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,YAAY,GACxB,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAExB"}

package/dist/components/tilemap.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tilemap component (M0 baseline rebuild).
+ *
+ * A Tilemap entity carries grid metadata + a single durable `tileset` GUID. The
+ * actual per-cell tile id array lives on attached `TileLayer` entities
+ * (one per render layer; ChildOf points back to the Tilemap entity).
+ *
+ * Defaults:
+ *   - `tileSize = [1, 1]` (unit-cell world coordinates).
+ *   - `chunkSize = 16` (tilemap-chunk-extract-system chunks 16x16 cells).
+ *
+ * @example Spawn a 32x32 unit-cell Tilemap referencing a TilesetAsset:
+ *   const tilemap = world.spawn(
+ *     { component: Tilemap, data: { cols: 32, rows: 32, tileset } },
+ *     { component: Transform, data: {} },
+ *   ).unwrap();
+ */
+export declare const Tilemap: import("@forgeax/engine-ecs").Component<"Tilemap", {
+    readonly cols: "u32";
+    readonly rows: "u32";
+    readonly tileSize: "array<f32, 2>";
+    readonly chunkSize: "u32";
+    readonly tileset: "string";
+}>;
+//# sourceMappingURL=tilemap.d.ts.map

package/dist/components/tilemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tilemap.d.ts","sourceRoot":"","sources":["../../src/components/tilemap.ts"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,OAAO;;;;;;EAQlB,CAAC"}

package/dist/components/visibility.d.ts

@@ -0,0 +1,22 @@
+/** Numeric labels stored by the public Visibility enum field. */
+export declare const VisibilityStateValue: Readonly<{
+    readonly inherited: 0;
+    readonly hidden: 1;
+    readonly visible: 2;
+}>;
+/** Author visibility intent accepted by the Visibility component. */
+export type VisibilityState = keyof typeof VisibilityStateValue;
+/**
+ * Decode the stored u32 without treating an unknown value as a valid state.
+ * Invalid values are rejected at ECS write boundaries; undefined remains an
+ * explicit signal for readers that inspect externally corrupted columns.
+ */
+export declare function visibilityStateFromU32(value: number): VisibilityState | undefined;
+/**
+ * Author intent for render participation. Omitted state is inherited and is
+ * therefore visible when no valid parent intent is available.
+ */
+export declare const Visibility: import("@forgeax/engine-ecs").Component<"Visibility", {
+    readonly state: "enum";
+}>;
+//# sourceMappingURL=visibility.d.ts.map

package/dist/components/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../src/components/visibility.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,eAAO,MAAM,oBAAoB;;;;EAItB,CAAC;AAEZ,qEAAqE;AACrE,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,oBAAoB,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAWjF;AAED;;;GAGG;AACH,eAAO,MAAM,UAAU;;EAkBtB,CAAC"}

package/dist/construct-renderer.d.ts

@@ -0,0 +1,19 @@
+import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import type { RhiBackendPack } from './assembly/backend-contract';
+import type { BundlerOptions } from './assembly/factory';
+import type { RendererHostImplementation, RendererLegacyHostAdapter } from './assembly/host-contract';
+import { type RenderError } from './errors/render';
+import type { Renderer, RendererOptions, RenderResult } from './render-contract';
+export type { EngineEnvironmentErrorDetail, RhiBackendInstrumentation, RhiBackendPack, } from './assembly/backend-contract';
+export { EngineEnvironmentError } from './assembly/backend-contract';
+export type { RendererLegacyHostAdapter } from './assembly/host-contract';
+export type { BundlerOptions };
+export type RendererFeatureAssemblyHost = Pick<RendererLegacyHostAdapter, 'installRenderFeature' | 'uninstallRenderFeature'>;
+export interface RendererHostAssembly {
+    readonly renderer: Renderer;
+    readonly debugDrawHost: RendererHostImplementation;
+    readonly featureHost: RendererFeatureAssemblyHost;
+    readonly assets: AssetRegistry;
+}
+export declare function constructRendererHost(canvas: unknown, options?: RendererOptions, bundler?: BundlerOptions, backend?: RhiBackendPack): Promise<RenderResult<RendererHostAssembly, RenderError>>;
+//# sourceMappingURL=construct-renderer.d.ts.map

package/dist/construct-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-renderer.d.ts","sourceRoot":"","sources":["../src/construct-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EACV,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,WAAW,EAAgC,MAAM,iBAAiB,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjF,YAAY,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,cAAc,GACf,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,YAAY,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAC1E,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAC5C,yBAAyB,EACzB,sBAAsB,GAAG,wBAAwB,CAClD,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,0BAA0B,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,2BAA2B,CAAC;IAClD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;CAChC;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE,cAAc,EACxB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,YAAY,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC,CA6B1D"}