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

package/dist/component.d.ts

@@ -0,0 +1,581 @@
+import { type Handle, type Result } from '@forgeax/engine-types';
+import type { EntityHandle } from './entity-handle';
+import type { ManagedColumnReader } from './storage/column';
+export { componentDefinition } from './component-schema';
+/** Bytes per element for each scalar field type. */
+declare const FIELD_SIZE_BYTES: {
+    readonly f32: 4;
+    readonly f64: 8;
+    readonly i32: 4;
+    readonly u32: 4;
+    readonly i16: 2;
+    readonly u16: 2;
+    readonly i8: 1;
+    readonly u8: 1;
+    readonly bool: 1;
+    readonly enum: 4;
+    readonly ref: 4;
+};
+/** Numeric scalar field types backed by TypedArray storage (legacy tier). */
+export type ScalarFieldType = keyof typeof FIELD_SIZE_BYTES;
+/**
+ * Legal element-type whitelist for the `array<T,N>` / `array<T>` vocab
+ * keywords (AC-03). T must be a scalar field type, `entity`, or a
+ * `shared\<X\>` template with a non-empty tag; reference / buffer / nested
+ * array element types are forbidden (OOS-08 / OOS-03).
+ *
+ * feat-20260614 M5 / w23: the historical `handle\<X\>` element family was
+ * deleted in favor of `shared\<X\>` (rc-tracked, lifecycle owned by
+ * SharedRefStore). The `MANAGED_ARRAY_ELEMENT_TYPES` Set remains
+ * static-scalar + entity only (D-8); dynamic `shared\<X\>` templates are
+ * validated by `isValidArrayElementType` at parse time.
+ *
+ * Legal: every member of `ScalarFieldType` plus `entity` plus
+ * `shared\<X\>` (non-empty tag). The `ref` legacy scalar keyword (a u32
+ * column placeholder) is in the whitelist; the parametric `unique<T>` /
+ * `shared<T>` scalars are rejected as array element types by AC-03.
+ */
+export type ManagedArrayElementType = ScalarFieldType | 'entity' | `shared<${string}>`;
+/**
+ * Schema-vocab keywords beyond the legacy scalar tier (AC-01).
+ *
+ * Each pattern is a template-literal type so a literal schema like
+ * `{ mat: 'unique<MaterialAsset>' }` types the value as
+ * `Handle<'MaterialAsset','unique'>` end-to-end. Runtime acceptance is
+ * gated by the internal `isSchemaVocabKeyword` check — the SSOT for parser fail-fast.
+ *
+ * The legacy `'buffer:<N>'` literal is retired one-cut by
+ * feat-20260515-buffer-array-vocab-collapse w4: replaced by the
+ * angle-bracket generic shapes `'buffer'` (variable byte slot) and
+ * `'buffer<N>'` (fixed byte slot). With `'array<T>'` / `'array<T, N>'` they
+ * form a 4-keyword closed surface across two orthogonal axes (element-type
+ * x capacity contract).
+ */
+export type SchemaVocabKeyword = 'string' | 'buffer' | `buffer<${number}>` | `unique<${string}>` | `shared<${string}>` | 'entity' | `array<${ManagedArrayElementType}, ${number}>` | `array<${ManagedArrayElementType}>`;
+/**
+ * Closed union of every keyword `defineComponent` accepts for a schema field.
+ * Combines the legacy scalar tier with the schema-vocab tier.
+ *
+ * `ComponentSchema` is keyed against this union; `defineComponent` rejects
+ * any field value not satisfying it (compile-time) or matching it
+ * (runtime).
+ */
+export type SchemaFieldType = ScalarFieldType | SchemaVocabKeyword;
+/**
+ * Producer-owned semantic shape tags for authoring/schema consumers.
+ *
+ * The ECS storage vocabulary remains the source of truth for bytes and
+ * runtime values. These tags capture the semantic shape that storage alone
+ * cannot express (for example an optional entity reference or a nested
+ * unique payload). The tag is deliberately closed so downstream consumers
+ * can exhaustively handle the representative field-shape vocabulary without
+ * creating a second component registry.
+ */
+export type FieldShapeKind = 'scalar' | 'boolean' | 'enum' | 'vector' | 'quaternion' | 'optional' | 'nested' | 'array' | 'asset-ref';
+/**
+ * Normalize any field-type keyword to its TYPE_METADATA key.
+ *
+ * The 11 legacy scalars round-trip their own key. The 6 vocab families normalize
+ * their parametric shapes to the family key:
+ *   - `unique<T>` / `shared<T>` — strip `<T>`    → `'ref'` / `'shared'`
+ *   - `buffer<N>`             — strip `<N>`       → `'buffer'`
+ *   - `array<T>` / `array<T,N>` — strip `<...>`   → `'array'`
+ *   - `entity` / `string` / `buffer` are identity.
+ *
+ * Returns `null` for an unrecognised keyword so callers can skip column
+ * allocation (same semantics as the retired `storageFieldType`).
+ */
+export declare function fieldTypeToMetaKey(fieldType: string): string | null;
+/**
+ * `true` when the schema field type is a managed-store slot - i.e. should be
+ * routed through `UniqueRefStore` (or `SharedRefStore` for `'shared<T>'`)
+ * for alloc / resolve / release. Derived from TYPE_METADATA[].isManaged
+ * column (feat-20260611-ecs-storage-naming-ssot D-3).
+ *
+ * Naming note (D-6 whitelist): `managed = ECS-tracked`. The prefix here is
+ * about column-side lifecycle ownership (the ECS releases the slot on
+ * despawn / overwrite), not the retired `'managed' | 'unmanaged'` Handle
+ * brand. Both `'unique<T>'` and `'shared<T>'` schema fields satisfy
+ * `isManagedField` because both are ECS-tracked; the dispatcher in
+ * `releaseManagedFieldOnRow` picks the right store per field type.
+ */
+export declare function isManagedField(fieldType: string): boolean;
+/**
+ * `true` when the schema field type is a managed-buffer slot - i.e. should be
+ * released by the M2 BufferPool release loop. Derived from
+ * TYPE_METADATA[].isBuffer column (feat-20260611-ecs-storage-naming-ssot D-3/D-4).
+ *
+ * D-4 semantic widening accepted: `buffer<abc>` resolves to metaKey 'buffer'
+ * (isBuffer=true) while the old regex-based impl rejected the non-integer N.
+ * This is a dead path — `defineComponent` rejects `buffer<abc>` via
+ * `isSchemaVocabKeyword` before the predicate fires.
+ *
+ * Naming note (D-6 whitelist): `managed = ECS-tracked`. Same semantic as
+ * `isManagedField` — the variable `'buffer'` keyword is one whose
+ * BufferPool slot the ECS releases at despawn / overwrite time.
+ */
+export declare function isManagedBufferField(fieldType: string): boolean;
+/**
+ * `true` when the schema field type is the single-entity reference keyword
+ * `'entity'`. Derived from TYPE_METADATA[].isEntityRef column
+ * (feat-20260611-ecs-storage-naming-ssot D-3).
+ */
+export declare function isEntityField(fieldType: string): boolean;
+/**
+ * `true` when the schema field type is an `array<T,N>` / `array<T>` vocab
+ * keyword. Derived from TYPE_METADATA[].isArray column
+ * (feat-20260611-ecs-storage-naming-ssot D-3).
+ *
+ * Naming note (D-6 whitelist): `managed = ECS-tracked`. Variable
+ * `array<T>` storage routes through BufferPool (slot lifecycle owned by
+ * the ECS); fixed `array<T,N>` is inline stride-N and has no separate
+ * slot to release, but both share this predicate as they share the
+ * `'array'` meta key.
+ */
+export declare function isManagedArrayField(fieldType: string): boolean;
+/**
+ * Set of legal element types for the `array<T,N>` / `array<T>` keywords
+ * (AC-03). Runtime mirror of `ManagedArrayElementType`.
+ *
+ * Naming note (D-6 whitelist): `MANAGED_ARRAY_ELEMENT_TYPES` keeps the
+ * `MANAGED` prefix because `managed = ECS-tracked` here — the Set is the
+ * static-whitelist arm of `isValidArrayElementType`, which gates which
+ * element types the ECS array dispatch knows how to retain / release.
+ * The `'shared<X>'` template family rides the `startsWith('shared<')`
+ * special case (D-8) rather than living in this Set.
+ */
+export declare const MANAGED_ARRAY_ELEMENT_TYPES: ReadonlySet<ManagedArrayElementType>;
+/**
+ * Parse an `array<T,N>` / `array<T>` schema string into its element type and
+ * optional fixed length. Returns `null` if the string is not a managed-array
+ * keyword or its element type is not in the whitelist (AC-03 runtime
+ * fail-safe).
+ *
+ * Examples:
+ *   parseManagedArraySchema('array<entity>')                => { elementType: 'entity', length: undefined }
+ *   parseManagedArraySchema('array<f32, 16>')               => { elementType: 'f32',    length: 16 }
+ *   parseManagedArraySchema('array<shared<MaterialAsset>>') => { elementType: 'shared<MaterialAsset>', length: undefined }
+ *   parseManagedArraySchema('array<shared<>>')              => null (empty tag rejection)
+ *   parseManagedArraySchema('array<unique<X>>')             => null (illegal element)
+ *   parseManagedArraySchema('array<array<f32,4>>')          => null (nested rejected)
+ *
+ * Naming note (D-6 whitelist): `parseManagedArraySchema` keeps the
+ * `Managed` infix because `managed = ECS-tracked` — every legal output
+ * shape this parser returns is one whose lifecycle the ECS knows how to
+ * retain / release on overwrite, despawn, or archetype migration.
+ */
+export declare function parseManagedArraySchema(fieldType: string): {
+    readonly elementType: ManagedArrayElementType;
+    readonly length: number | undefined;
+} | null;
+/**
+ * Parse the byte count out of a `buffer<N>` schema keyword. Returns NaN if
+ * the input does not match the keyword pattern - callers that already gated
+ * via `isManagedBufferField` get a guaranteed-positive integer for the
+ * fixed-byte form. The bare `'buffer'` keyword (variable byte capacity)
+ * returns NaN and callers must check `fieldType === 'buffer'` separately.
+ */
+export declare function bufferFieldByteLength(fieldType: string): number;
+/**
+ * Runtime check for a schema-vocab keyword (the tier-2 surface).
+ *
+ * Pure-function regex match — kept off the hot path; only invoked by
+ * `defineComponent` once per field at registration time. The match patterns
+ * are the runtime mirror of `SchemaVocabKeyword` template literals.
+ *
+ * - `'string'` is exact-match (bare literal, no `<>`).
+ * - `'buffer'` is exact-match (variable-byte capacity).
+ * - `buffer<N>` requires `N` to be a positive base-10 integer (`/^[1-9]\d*$/`).
+ *   Forms like `buffer<abc>` / `buffer<0>` / `buffer<>` are rejected.
+ * - `unique<T>` / `shared<T>` require a non-empty target tag (`/^\w+$/`).
+ * - `entity` is exact-match.
+ * - `array<T,N>` / `array<T>` accept only the whitelist element types
+ *   (`MANAGED_ARRAY_ELEMENT_TYPES`); illegal inner types fall through and
+ *   the caller surfaces `managed-array-element-type-not-allowed`.
+ */
+export declare function isSchemaVocabKeyword(s: string): s is SchemaVocabKeyword;
+/**
+ * JS value-shape per managed-array element type. `entity` maps to `Entity`
+ * (branded number), every scalar maps to `number` (bool is stored as a 0/1
+ * byte and read back as 0 or 1).
+ */
+export type ManagedArrayElementValue<T extends ManagedArrayElementType> = T extends 'entity' ? EntityHandle : number;
+/**
+ * Maps each field-type keyword to the JS value type read/written by it.
+ *
+ * Tier-1 (legacy scalars) widens to `boolean | number`; tier-2 (schema-vocab)
+ * resolves to the corresponding handle / entity / buffer / array / string
+ * shape via the `infer T` template-literal extraction pattern. Conditional
+ * types resolve top-down --- the `'string'` arm sits BEFORE the array<...> /
+ * `buffer<N>` arms so the precise literal wins template-literal resolution
+ * (R-P5: prevents `'string'` from being shadowed by a wider template-literal
+ * pattern). The fixed-capacity `array<T,N>` arm matches before the
+ * variable-capacity `array<T>` arm by the same rule.
+ *
+ * The 4 buffer/array keywords (`'buffer'` / `'buffer<N>'` / `'array<T>'` /
+ * `'array<T, N>'`) all resolve directly to a concrete TypedArray (or
+ * Uint8Array for the byte-only buffer family). The materialised value is a
+ * read-only snapshot: for fixed `buffer<N>` / `array<T,N>` it aliases the
+ * inline column buffer (feat-20260602); for variable `buffer` / `array<T>`
+ * it aliases the BufferPool slot bytes (plan-strategy §2.2 D-R3 contract).
+ * Mutation flows through `world.set` / `world.push` / `world.pop`
+ * not direct assignment to the returned TypedArray.
+ *
+ * The `'string'` arm resolves to a native JS `string` (D-R1 / AC-13): the
+ * dispatch routes the column u32 through `UniqueRefStore.resolve(handle)`
+ * which returns the immutable string payload by reference.
+ */
+export type FieldValueType<T extends SchemaFieldType> = T extends 'bool' ? boolean : T extends 'entity' ? EntityHandle | null : T extends 'string' ? string : T extends 'buffer' ? Uint8Array : T extends `buffer<${number}>` ? Uint8Array : T extends `array<shared<${infer Target}>, ${number}>` ? readonly Handle<Target, 'shared'>[] : T extends `array<shared<${infer Target}>>` ? readonly Handle<Target, 'shared'>[] : T extends `array<${infer Elem extends ManagedArrayElementType}, ${number}>` ? TypedArrayFor<Elem extends 'entity' ? 'u32' : Elem> : T extends `array<${infer Elem extends ManagedArrayElementType}>` ? TypedArrayFor<Elem extends 'entity' ? 'u32' : Elem> : T extends `unique<${infer Target}>` ? Handle<Target, 'unique'> : T extends `shared<${infer Target}>` ? Handle<Target, 'shared'> : T extends ScalarFieldType ? number : never;
+/**
+ * Input-side counterpart of {@link FieldValueType} for write paths
+ * (`world.spawn` / `world.addComponent` / `world.set`).
+ *
+ * Asymmetric on `array<scalar, N>` / `array<scalar>` ONLY: the read side
+ * surfaces zero-copy `Float32Array` / `Uint32Array` / etc views; the write
+ * side ALSO accepts `readonly number[]` because writeArrayField copies bytes
+ * verbatim from either shape (TypedArray subarray() OR per-element pack via
+ * DataView). Plain literals like `times: [0.5]` reach the same code path
+ * with no Float32Array wrapper boilerplate at the call site, and short
+ * prefixes pad the row tail with zero (writeArrayField D-3 contract).
+ *
+ * Asymmetric on `buffer` / `buffer<N>`: the read side returns `Uint8Array`,
+ * but the write side accepts any `AllowSharedBufferSource` (Float32Array /
+ * ArrayBuffer / Uint8Array / any TypedArray). The ECS buffer-write ingestion
+ * point (`World.writeRow` / `World.set`) normalizes any view to `Uint8Array`
+ * over its raw bytes before storing (feat-20260621 V2 / AC-A4). This lets AI
+ * users write typed param payloads directly, e.g.
+ * `world.set(e, PostProcessParams, { data: Float32Array.of(exposure,0,0,0) })`,
+ * without manual byte-reinterpret boilerplate at the call site.
+ *
+ * Every other arm matches FieldValueType verbatim (no widening): handles
+ * are already arrays-of-handle, scalars stay number, etc.
+ */
+export type FieldInputType<T extends SchemaFieldType> = T extends 'bool' ? boolean : T extends 'entity' ? EntityHandle | null : T extends 'string' ? string : T extends 'buffer' ? AllowSharedBufferSource : T extends `buffer<${number}>` ? AllowSharedBufferSource : T extends `array<shared<${infer Target}>, ${number}>` ? readonly Handle<Target, 'shared'>[] : T extends `array<shared<${infer Target}>>` ? readonly Handle<Target, 'shared'>[] : T extends `array<${infer Elem extends ManagedArrayElementType}, ${number}>` ? TypedArrayFor<Elem extends 'entity' ? 'u32' : Elem> | readonly number[] : T extends `array<${infer Elem extends ManagedArrayElementType}>` ? TypedArrayFor<Elem extends 'entity' ? 'u32' : Elem> | readonly number[] : T extends `unique<${infer Target}>` ? Handle<Target, 'unique'> : T extends `shared<${infer Target}>` ? Handle<Target, 'shared'> : T extends ScalarFieldType ? number : never;
+/**
+ * Maps a SchemaFieldType to its zero-copy query-column view type.
+ *
+ * Three storage shapes share the keyword space:
+ *
+ * 1. Scalar / fixed-inline columns -- the column buffer is the data, written
+ *    in place. The bundle entry is a concrete writable TypedArray of the
+ *    correct ctor (`f32` -> `Float32Array`, `'buffer<N>'` -> `Uint8Array`,
+ *    `'array<T,N>'` -> the T-typed array). Direct index assignment is
+ *    fine -- the column owns the bytes.
+ *
+ * 2. `shared\<X\>` (rc-tracked AssetRegistry reference) -- the column carries
+ *    a u32 handle id; SharedRefStore owns the rc lifecycle. The bundle
+ *    entry is a `ManagedColumnReader<T>` (D-4 / D-7) -- read-only, walk
+ *    via `.get(i)`. Consumers route through `assets.get(handle)` to
+ *    materialise the asset payload.
+ *
+ * 3. The 4 managed-vocab keywords -- `'string'` / `` `ref<T>` `` / variable
+ *    `'buffer'` / variable `` `array<T>` `` -- the column carries a u32 slot
+ *    id; the payload lives in `UniqueRefStore` / `BufferPool`. The bundle
+ *    entry is a `ManagedColumnReader<T>` (D-4 / D-7) -- read-only by
+ *    construction, no index signature. Mutation MUST flow through the
+ *    public dispatch (`world.set` / `world.push` / `world.allocUniqueRef`).
+ *
+ * The `extends SchemaFieldType` upper bound matches `ComponentSchema[K]`
+ * so query bundle types do not have to pre-filter.
+ */
+export type TypedArrayFor<T extends SchemaFieldType> = T extends 'f32' ? Float32Array : T extends 'f64' ? Float64Array : T extends 'i32' ? Int32Array : T extends 'u32' | 'enum' | 'ref' | 'entity' ? Uint32Array : T extends 'i16' ? Int16Array : T extends 'u16' ? Uint16Array : T extends 'i8' ? Int8Array : T extends 'u8' | 'bool' ? Uint8Array : T extends 'string' ? ManagedColumnReader<'string'> : T extends `unique<${string}>` ? ManagedColumnReader<T> : T extends `shared<${string}>` ? ManagedColumnReader<T> : T extends 'buffer' ? ManagedColumnReader<'buffer'> : T extends `buffer<${number}>` ? Uint8Array : T extends `array<${infer Elem extends ManagedArrayElementType}, ${number}>` ? TypedArrayFor<Elem extends 'entity' | `shared<${string}>` ? 'u32' : Elem> : T extends `array<${string}>` ? ManagedColumnReader<T> : never;
+/**
+ * Relationship metadata (feat-20260531 M2 / plan-strategy D-5). Declares this
+ * component as the holder side of a Bevy-style bidirectional relationship: the
+ * holder carries a single `entity` field (the target), and the engine mirrors
+ * the reverse reference into `mirror`.`field` (an `array<entity>` on the target
+ * entity) at add / remove / despawn time.
+ *
+ * - `mirror` — the mirror component's string NAME (not a type reference, so
+ *   `engine-ecs` never imports the mirror component type; AC-29). The mirror
+ *   component is a derived runtime view rebuilt by the relationship owner, so
+ *   it MUST declare `transient: true` — otherwise scene collect serializes it
+ *   and `instantiateScene` double-writes (serialized copy + owner rebuild).
+ * - `field` — the `array<entity>` field on the mirror component that holds the
+ *   reverse list. Validated to be exactly `'array<entity>'` at `defineComponent` time.
+ * - `exclusive` — when `true`, re-adding the holder component with a new target
+ *   auto-reparents (clears the old mirror entry, then appends the new one)
+ *   instead of returning `ComponentAlreadyPresentError` (AC-12).
+ * - `linkedSpawn` — when `true`, despawning the target recursively despawns the
+ *   holders in its mirror list. Default `false` (D-1): despawn only prunes the
+ *   mirror entry, the holder entity survives.
+ */
+/** A schema is a record of field-name → field-type keyword. */
+export type ComponentSchema = Record<string, SchemaFieldType>;
+/** Derive the JS value-shape from a schema (read side; zero-copy views). */
+export type ShapeOf<S extends ComponentSchema> = {
+    [K in keyof S]: FieldValueType<S[K]>;
+};
+/**
+ * Derive the input-side value-shape from a schema (write side; widens
+ * `array<scalar>` to also accept `readonly number[]` plus the strict
+ * TypedArray view). Used by `world.spawn` / `world.addComponent` /
+ * `world.set` `data` so AI users can write `times: [0.5]` instead of the
+ * `new Float32Array([0.5])` boilerplate. writeArrayField walks both shapes
+ * via the same byte-copy path so runtime semantics are identical.
+ */
+export type InputShapeOf<S extends ComponentSchema> = {
+    [K in keyof S]: FieldInputType<S[K]>;
+};
+/** @internal Barrel-only check for the id=0 Entity import-order invariant. */
+export declare function isComponentDefinitionOrderValid(): boolean;
+/** @internal Read the owner-assigned identity for storage/archetype code. */
+export declare function componentId(component: Component): ComponentId;
+/** @internal Derive the flat type map from the fields SSOT. */
+export declare function componentSchema<const C extends Component>(component: C): Readonly<SchemaOf<C>>;
+/** Numeric identifier for a component type, used by bitmask matching and archetype edges. */
+export type ComponentId = number;
+export type ComponentStorage = 'table' | 'sparse';
+declare const __componentBrand: unique symbol;
+/**
+ * Opaque component token. Carries the component name `N` as a string-literal
+ * type parameter (lifted from the `defineComponent` call site via `<const N>`)
+ * and the schema-shape `S` as a phantom brand so `world.get(e, Comp)` can
+ * return `Result<ShapeOf<S>, EcsError>` precisely.
+ *
+ * The `N` parameter defaults to `string` to keep existing single-parameter
+ * `Component<S>` annotations source-compatible. When inferred from a
+ * `defineComponent('Position', ...)` call, `N` is the literal `'Position'`,
+ * which lets query row/span mapped types resolve `{ [K in N]: ... }` to a
+ * concrete keyed object instead of a degraded index signature (KD-1).
+ */
+export interface Component<N extends string = string, S extends ComponentSchema = ComponentSchema> {
+    readonly name: N;
+    /** The one schema projection: type, default, and enum labels per field. */
+    readonly fields: Readonly<Record<keyof S & string, FieldReflection>>;
+    readonly storage: ComponentStorage;
+    readonly [__componentBrand]: ShapeOf<S>;
+}
+/**
+ * One row of the global type-metadata table. Carries the type-intrinsic
+ * properties a field type has regardless of which component declares it.
+ *
+ * - `byteSize` — element byte width for the column-storage scalar; `undefined`
+ *   for families whose storage byte size is not a fixed per-type constant
+ *   (variable buffer / array slot ids are u32-stored, surfaced via `storage`).
+ * - `viewCtor` — TypedArray constructor for the column storage; `undefined`
+ *   for families without a direct TypedArray column.
+ * - `storage` — the column-storage scalar type this field routes to (every
+ *   vocab family stores a u32 slot id / handle).
+ * - `isScalar` — member of the 11 concrete scalar types
+ *   (`f32`/`f64`/`i32`/`u32`/`i16`/`u16`/`i8`/`u8`/`bool`/`enum`/`ref`).
+ * - `isManaged` — routed through `UniqueRefStore` (string / ref<T>).
+ * - `isBuffer` — a `buffer` / `buffer<N>` managed-byte slot.
+ * - `isEntityRef` — the single-entity `entity` reference keyword.
+ * - `isArray` — an `array<T>` / `array<T,N>` keyword.
+ */
+export interface TypeMetadataRow {
+    readonly byteSize: number | undefined;
+    readonly viewCtor: Float32ArrayConstructor | Float64ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int8ArrayConstructor | Uint8ArrayConstructor | undefined;
+    readonly storage: ScalarFieldType;
+    readonly isScalar: boolean;
+    readonly isManaged: boolean;
+    readonly isBuffer: boolean;
+    readonly isEntityRef: boolean;
+    readonly isArray: boolean;
+}
+/**
+ * Global per-type metadata table. Keyed by concrete scalar type (11) plus
+ * vocab family (6 — `entity` / `string` / `buffer` / `ref` / `handle` /
+ * `array`). The `ref` key is shared by the legacy scalar and the vocab family
+ * (see header). Every vocab family stores a u32 slot id / handle.
+ *
+ * Built once at module load; frozen so downstream consumers (column.ts /
+ * archetype.ts / world.ts, migrated M2) read a stable single source.
+ */
+export declare const TYPE_METADATA: Readonly<Record<string, TypeMetadataRow>>;
+/**
+ * Pre-parsed `array<T>` / `array<T,N>` reflection. Bare length sentinel
+ * (D-A1 user ruling): `length` present => fixed-capacity, `length === undefined`
+ * => variable-capacity. No `isVariable` / `kind` field — both are losslessly
+ * derivable from `length` presence (architecture-principles.md #2 Derive). This
+ * is exactly the existing `parseManagedArraySchema` return shape (zero shape
+ * change).
+ */
+export interface ArrayMeta {
+    readonly elementType: ManagedArrayElementType;
+    readonly length?: number;
+}
+/**
+ * Input field-descriptor object (D-A3). The second `defineComponent` argument
+ * may declare each field either as a bare type keyword (legacy flat form,
+ * still accepted through M2; migrated repo-wide in M3) or as a descriptor
+ * object aggregating `type` + `default` + semantic `shape` + field-level
+ * `meta`.
+ *
+ * - `type` — the schema field-type keyword (a parametrized string such as
+ *   `'array<f32,3>'` / `'unique<MaterialAsset>'` is used verbatim, D-A2).
+ * - `default` — layer-2 default value; retained in the field reflection row.
+ * - `shape` — producer-owned semantic shape tag for schema consumers; it does
+ *   not change ECS storage or runtime value semantics.
+ * - `meta` — field-level open namespace; aggregated into `component.meta`. The
+ *   infra gives no key special meaning (open map, OOS-1).
+ * - `transient` — when `true`, scene collect skips this field (D-5). Same word,
+ *   same meaning as the component-level `transient` flag, with granularity sunk
+ *   to the field level: a field that is derived/reconstructable (e.g. a resolved
+ *   world mat4) is excluded from serialization while its component's persisted
+ *   fields still round-trip. Absent (the common case) means the field is
+ *   serialized.
+ * - `labels` — for an `enum` field ONLY: the label→numeric-value map (e.g.
+ *   `{ static: 0, dynamic: 1, kinematic: 2 }`). An `enum` field stores a bare
+ *   `u32` variant index; the human-readable names historically lived in a
+ *   SEPARATE per-package const map (`RigidBodyTypeValue`) + comment table, so no
+ *   schema consumer could read them and the two could drift. Declaring `labels`
+ *   attaches that map to the field itself (SSOT-adjacent): it is aggregated into
+ *   `component.fields[field].labels` and surfaced by reflection consumers (the
+ *   editor's `describeComponent`, inspector UIs, validation hints) so a
+ *   docs-only user learns the legal variants + their integers from the schema
+ *   alone. Pass the EXISTING `*Value` const map here (Derive, don't Duplicate —
+ *   one object, two consumers). Absent for non-enum fields / enums that opt out.
+ */
+export interface FieldDescriptor<T extends SchemaFieldType = SchemaFieldType> {
+    readonly type: T;
+    readonly default?: FieldValueType<T>;
+    /** Semantic authoring shape; storage still follows `type`. */
+    readonly shape?: FieldShapeKind;
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly transient?: boolean;
+    readonly labels?: Readonly<Record<string, number>>;
+}
+/**
+ * Per-field reflection produced at registration time and read off
+ * `component.fields[fieldName]` (D-A3). Carries the pre-parsed facts: the
+ * field `type`, its `default` (if any), semantic `shape` (if declared), — for
+ * `array<...>` fields only — the pre-parsed `arrayMeta` (parse happens once at
+ * registration, AC-03c), and the field-level `transient` flag (D-5) when
+ * declared.
+ *
+ * `transient` mirrors the component-level `Component.transient` (same word,
+ * same meaning): scene collect skips a `transient` field just as it skips a
+ * `transient` component. Granularity is sunk to the field level so a component
+ * can persist most of its fields while excluding a derived/reconstructable one
+ * (e.g. `Transform.world`). Absent means the field participates in
+ * serialization.
+ */
+export interface FieldReflection {
+    readonly type: SchemaFieldType;
+    readonly default?: unknown;
+    /** Producer-declared semantic shape, when storage type alone is insufficient. */
+    readonly shape?: FieldShapeKind;
+    readonly arrayMeta?: ArrayMeta;
+    readonly transient?: boolean;
+    /**
+     * For an `enum` field: the label→numeric-value map declared on the field
+     * descriptor (see `FieldDescriptor.labels`). Lets a schema consumer resolve a
+     * variant name ↔ its stored `u32` index without a separate const map. Absent
+     * for non-enum fields / enums that did not declare labels.
+     */
+    readonly labels?: Readonly<Record<string, number>>;
+}
+/**
+ * One input field-spec value: either the bare type keyword (legacy flat form)
+ * or a field-descriptor object. Accepting both keeps the ~44 flat-string
+ * call-sites + ~55 test files green through M1/M2 while the field-descriptor
+ * form is migrated in repo-wide in M3 (D-A7 / D-A8 shrink the migration
+ * surface to the input side only).
+ */
+export type FieldSpec<T extends SchemaFieldType = SchemaFieldType> = T | FieldDescriptor<T>;
+/** An input field-spec map: field-name -> bare keyword | field-descriptor. */
+export type FieldsInput = Record<string, FieldSpec>;
+/**
+ * Project an input field-spec map down to its flat `ComponentSchema` shape
+ * (field-name -> type keyword). A bare-keyword spec maps to itself (identity,
+ * so existing flat-string call-sites infer exactly as before); a descriptor
+ * spec maps to its `type`. This keeps `Component<N, SchemaOf<F>>` driving every
+ * downstream type (ShapeOf / query row/span projection / TypedArrayFor) unchanged.
+ */
+export type SchemaOf<F extends FieldsInput | Component> = F extends Component<string, infer S> ? S : F extends FieldsInput ? {
+    [K in keyof F]: F[K] extends FieldDescriptor<infer T> ? T : F[K] extends SchemaFieldType ? F[K] : never;
+} : never;
+/** Optional configuration for `defineComponent` (w4, M3 consumer; w21 layer-2 defaults). */
+export interface DefineComponentOptions {
+    readonly storage?: ComponentStorage;
+    /**
+     * When `true`, the component is skipped by scene collect
+     * (rootsToSceneAsset). The component stays in archetype columns and
+     * participates normally in queries / world.get at runtime.
+     *
+     * Default: `false`. Mirror targets of relationship components should
+     * declare `transient: true` so they are not serialized (their state is
+     * rebuilt by the mirror hook after instantiateScene).
+     */
+    readonly transient?: boolean;
+    /**
+     * Component-level open metadata namespace. Entries are copied into
+     * `Component.meta` at registration; the ECS core assigns no meaning to any
+     * key. Component-level entries win over field-level entries with the same
+     * key, and consumers may extend the mutable map after registration.
+     */
+    readonly meta?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Define a component. Returns a frozen opaque token with exactly three runtime
+ * facts: `.name`, `.fields`, and `.storage`. Numeric identity, flat schema,
+ * and defaults are owner projections held outside the token.
+ *
+ * The second argument accepts each field either as a bare type keyword
+ * ('f32', 'array<entity>', ...) or as a field-descriptor object
+ * `{ type, default?, meta? }` (D-A3). The single `FieldsInput` overload
+ * handles both forms — bare keywords are identity through `SchemaOf<F>`.
+ *
+ * The `<const N>` modifier lifts `name` to its string-literal type so the
+ * returned `Component<N, SchemaOf<S>>` drives precise key-based mapped types
+ * downstream (for example QueryRow and QuerySpan projections). At runtime `name` is a plain
+ * string.
+ *
+ * Schema-field validation accepts both the legacy scalar tier
+ * (`ScalarFieldType`, 11 keywords) and the schema-vocab tier
+ * (`SchemaVocabKeyword`, 8 patterns including `array<T,N>` / `array<T>` /
+ * `buffer` / `buffer<N>`). Mismatched values raise
+ * `SchemaUnsupportedFieldError`. Illegal `array<...>` element types
+ * (e.g. `array<ref<X>>`) raise `ManagedArrayElementTypeNotAllowedError`
+ * (AC-03 runtime fail-safe).
+ *
+ * Relationship roles are declared through `defineRelationship`; component
+ * definitions contain only schema vocabulary and no mirror metadata.
+ *
+ * @throws SchemaUnsupportedFieldError for any field type not in the supported
+ *   set, or a field-descriptor object missing its `type`.
+ * @throws ManagedArrayElementTypeNotAllowedError when an `array<...>`
+ *   keyword carries an illegal element type.
+ * @throws RelationshipMirrorComponentNotRegisteredError when
+ *   `relationship.mirror` names a component not yet defined.
+ * @throws RelationshipMirrorFieldTypeMismatchError when the mirror's
+ *   `relationship.field` is missing or not typed `'array<entity>'`.
+ */
+export declare function defineComponent<const N extends string, const S extends FieldsInput>(name: N, fields: S, options?: DefineComponentOptions): Component<N, SchemaOf<S>>;
+export declare class ComponentInUseError extends Error {
+    readonly name = "ComponentInUseError";
+    readonly code: "component-in-use";
+    readonly expected = "the component to have no live entity or scheduled-system references";
+    readonly hint = "Remove owning systems and component values before disposing the registration lease.";
+    readonly detail: {
+        readonly componentName: string;
+    };
+    constructor(componentName: string);
+}
+export declare class ComponentNameConflictError extends Error {
+    readonly name = "ComponentNameConflictError";
+    readonly code: "component-name-conflict";
+    readonly expected = "one component token per name in a World";
+    readonly hint = "Use the token already registered in this World or choose a distinct component name.";
+    readonly detail: {
+        readonly componentName: string;
+    };
+    constructor(componentName: string);
+}
+export type ComponentCatalogError = ComponentInUseError | ComponentNameConflictError;
+export interface ComponentLease {
+    readonly component: Component;
+    dispose(): Result<void, ComponentInUseError>;
+}
+/** World-local discovery and ownership boundary for plugin-installed component vocabulary. */
+export declare class ComponentCatalog {
+    private readonly inUse;
+    private readonly registrations;
+    constructor(inUse: (component: Component) => boolean);
+    register(component: Component): Result<ComponentLease, ComponentNameConflictError>;
+    resolve(name: string): Component | undefined;
+    entries(): ReadonlyMap<string, Component>;
+}
+//# sourceMappingURL=component.d.ts.map

package/dist/component.d.ts.map

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