@oasys/oecs 0.5.3 → 0.6.0

package/dist/core/ecs/component.d.cts

@@ -19,12 +19,12 @@ export type FieldValues<S extends ComponentSchema> = {
     readonly [K in keyof S]: number;
 };
 /**
- * Values argument tuple for attaching a component of schema `S` — empty for a
+ * Values argument tuple for attaching a component of schema `S`, empty for a
  * tag, a single optional partial-values map otherwise. A tag schema
  * (`Record<string, never>`) would otherwise degenerate: `keyof` an
  * index-signature record is `string`, so `Partial<FieldValues<…>>` collapses to
  * `Record<string, number>` and `Frozen({ anything: 1 })` compiles. The
- * conditional forbids values on tags outright; a schema-erased `ComponentDef`
+ * conditional forbids values on tags outright. A schema-erased `ComponentDef`
  * falls into the valued branch, so untyped call sites keep the loose shape.
  */
 export type ValuesArg<S extends ComponentSchema> = S extends Record<string, never> ? [] : [values?: Partial<FieldValues<S>>];
@@ -32,16 +32,16 @@ export type ValuesArg<S extends ComponentSchema> = S extends Record<string, neve
  * `FieldValues` for APIs where the values object is required and complete
  * (`addComponent`'s valued overload, the host-seam `SpawnEntry`). Guards the
  * same tag degeneracy as `ValuesArg`: a tag accepts only the empty object
- * (`Record<string, never>` — every property typed `never`), so
+ * (`Record<string, never>`, every property typed `never`), so
  * `addComponent(e, Frozen, { x: 1 })` is a compile error while the
  * tag-overload-less call sites can still pass `{}`.
  */
 export type CompleteFieldValues<S extends ComponentSchema> = S extends Record<string, never> ? Record<string, never> : FieldValues<S>;
 /**
  * Trailing-argument tuple for the attach surfaces (`ctx.commands.add`'s
- * explicit-values form, `ctx.addSparse`): a tag takes NO values argument, a valued schema REQUIRES a
- * complete one. Encodes the former tag/valued overload pair as one signature,
- * which the typed system seam needs — its `def` parameter is a single
+ * explicit-values form, `ctx.addSparse`): a tag takes no values argument, a valued schema requires a
+ * complete one. Encodes the former tag and valued overload pair as one signature,
+ * which the typed system seam needs, its `def` parameter is a single
  * declared-access-constrained type param, and per-schema overloads would
  * re-introduce the tag-vs-valued split on top of it.
  */
@@ -51,10 +51,10 @@ export type ColumnsForSchema<S extends ComponentSchema> = {
     readonly [K in keyof S]: TagToTypedArray[S[K]];
 };
 /**
- * Mutable sibling of `ColumnsForSchema` — the field-keyed column group handed
- * back by `eachChunk`'s `cols.mut(def)` (no `readonly`, since the whole point
+ * Mutable sibling of `ColumnsForSchema`, the field-keyed column group handed
+ * back by `forEachChunk`'s `cols.mut(def)` (no `readonly`, since the whole point
  * is in-place writes). The change-tick is stamped once when the group is
- * resolved, so the per-row loop is plain typed-array indexing (§eachChunk).
+ * resolved, so the per-row loop is plain typed-array indexing.
  */
 export type MutableColumnsForSchema<S extends ComponentSchema> = {
     [K in keyof S]: TagToTypedArray[S[K]];
@@ -62,28 +62,28 @@ export type MutableColumnsForSchema<S extends ComponentSchema> = {
 declare const __schema: unique symbol;
 /**
  * A component handle. **Callable**: `Pos({ x, y })` produces a `Bundle` (omitted
- * fields zero-fill at attach), so one varargs shape — `spawn(Pos({x,y}),
- * Vel({vx:1}), IsEnemy)` — replaces the older incompatible attach shapes. A bare
- * `Pos` (uncalled) still stands in for a tag / all-zero values wherever a
+ * fields zero-fill at attach), so one varargs shape, `spawn(Pos({x,y}),
+ * Vel({vx:1}), IsEnemy)`, replaces the older incompatible attach shapes. A bare
+ * `Pos` (uncalled) still stands in for a tag, or for all-zero values, wherever a
  * `BundleOrDef` is accepted.
  *
  * The numeric component id lives on `.id` (registration order). Consumers treat
- * the def as an opaque handle; internal code reads `def.id` where it needs the
+ * the def as an opaque handle. Internal code reads `def.id` where it needs the
  * raw id. The call signature's `S` makes `ComponentDef<{x:"f64"}>` distinct from
  * `ComponentDef<{vx:"f64"}>`.
  *
- * The optional `[__schema]` slot never exists at runtime; it re-states `S` in a
- * covariant tuple position so that a TAG def type is not a universal assignment
+ * The optional `[__schema]` slot never exists at runtime. It re-states `S` in a
+ * covariant tuple position so that a tag def type is not a universal assignment
  * sink. Through the call signature alone every def is assignable to
  * `ComponentDef<Record<string, never>>` (the tag callable takes no required
- * args and any `Bundle` satisfies its return), which would let ONE tag in a
+ * args and any `Bundle` satisfies its return), which would let one tag in a
  * system's declared-access union admit every component at compile time
- * (§typestate — `DeclaredRead` and friends in system.ts). With the slot, a
+ * (`DeclaredRead` and friends in system.ts). With the slot, a
  * valued schema is not assignable to the tag schema (`"f64" ⊀ never`), while
  * schema erasure (`ComponentDef<S>` → bare `ComponentDef`) still works because
  * every schema is assignable to `ComponentSchema`.
  *
- * Build one with `makeComponentDef`; never construct by hand.
+ * Build one with `createComponentDef`. Never construct by hand.
  */
 export interface ComponentDef<S extends ComponentSchema = ComponentSchema> {
     (...values: ValuesArg<S>): Bundle<S>;
@@ -92,17 +92,17 @@ export interface ComponentDef<S extends ComponentSchema = ComponentSchema> {
 }
 /**
  * Recover a def's schema type: `SchemaOf<typeof Pos>` is `{x:"f64", y:"f64"}`.
- * The typed `SystemContext` methods (§typestate) constrain their `def`
+ * The typed `SystemContext` methods (system.ts) constrain their `def`
  * parameter to the system's declared-access union and use this to type the
  * field argument, in place of taking `ComponentDef<S>` directly.
  */
 export type SchemaOf<D> = D extends ComponentDef<infer S extends ComponentSchema> ? S : never;
 /**
- * `unknown` if `D` is one of the query's declared terms, else an error tuple —
- * the query-seam sibling of system.ts's `DeclaredRead` (§typestate,
- * POLISH_AUDIT #6). `Query.eachChunk`'s cursor and `ArchetypeView`'s column
+ * `unknown` if `D` is one of the query's declared terms, else an error tuple,
+ * the query-seam sibling of system.ts's `DeclaredRead`.
+ * `Query.forEachChunk`'s cursor and `ArchetypeView`'s column
  * accessors intersect this into their `def` parameter so fetching a component
- * that is NOT a term of the iterating query fails to compile (previously
+ * that is not a term of the iterating query fails to compile (previously
  * caught only by the dev-mode access check, and only when the system's
  * declaration was itself wrong). Same encoding rules as the system asserts:
  * stable `D extends ComponentDef<any>` constraints keep instantiations
@@ -110,15 +110,15 @@ export type SchemaOf<D> = D extends ComponentDef<infer S extends ComponentSchema
  */
 export type DeclaredQueryTerm<Defs extends readonly ComponentDef<any>[], D> = [D] extends [
     Defs[number]
-] ? unknown : ["component is not a term of this query — add it with .and(...)", D];
-/** Options bag accepted by `registerComponent` / `registerSparseComponent`. */
+] ? unknown : ["component is not a term of this query, add it with .and(...)", D];
+/** Options bag accepted by `registerComponent` and `registerSparseComponent`. */
 export interface ComponentRegisterOptions {
-    /** Debug label for diagnostics — errors then read `'Pos' (component 5)`
+    /** Debug label for diagnostics, errors then read `'Pos' (component 5)`
      * instead of `component 5`. Never affects behaviour, layout, or hashing. */
     readonly name?: string;
 }
 /**
- * Schema-erased component handle — just the `.id`. Internal, schema-agnostic
+ * Schema-erased component handle, only the `.id`. Internal, schema-agnostic
  * code (access checks, dirty-set notes, field-id lookup) takes this instead of
  * `ComponentDef`: the callable signature makes `ComponentDef<S>` *invariant* in
  * `S` (a generic `ComponentDef<S>` is not assignable to `ComponentDef`), but
@@ -131,27 +131,27 @@ export type ComponentHandle = {
 /**
  * Mint a callable `ComponentDef` for a freshly-registered component id. The
  * returned function produces a `Bundle` when called (`Pos({x,y})`) and carries
- * its numeric id on a non-enumerable `.id` (invisible to spreads / `JSON`).
- * The single cast bridges the function value to the branded handle type — the
- * `.id` is installed at runtime by `defineProperty` (§10c branded-ID boundary).
+ * its numeric id on a non-enumerable `.id`, invisible to a spread and to `JSON`.
+ * The single cast bridges the function value to the branded handle type, the
+ * `.id` is installed at runtime by `defineProperty` (the branded-ID boundary).
  */
-export declare function makeComponentDef<S extends ComponentSchema>(id: ComponentID): ComponentDef<S>;
+export declare function createComponentDef<S extends ComponentSchema>(id: ComponentID): ComponentDef<S>;
 export interface Bundle<S extends ComponentSchema = ComponentSchema> {
     readonly def: ComponentDef<S>;
     readonly values: Partial<FieldValues<S>>;
 }
-/** Either a populated bundle or a bare def (tag / all-fields-zero). */
+/** Either a populated bundle or a bare def, a tag with all fields zero. */
 export type BundleOrDef<S extends ComponentSchema = ComponentSchema> = Bundle<S> | ComponentDef<S>;
-/** Re-validate one bundle-or-def item against its OWN def's schema. A bare def
- * (the callable) passes as-is; a bundle is re-stated as `Bundle<S>` for its
+/** Re-validate one bundle-or-def item against its own def's schema. A bare def
+ * (the callable) passes as-is. A bundle is re-stated as `Bundle<S>` for its
  * def's `S`, so a hand-written `{ def, values }` literal whose fields don't
- * match the def is rejected — closing the raw-literal leak that `bundle(Pos,…)`
- * / `Pos(…)` never had (those validate at their own call site). Per-element
+ * match the def is rejected, closing the raw-literal leak that `bundle(Pos,…)`
+ * and `Pos(…)` never had (those validate at their own call site). Per-element
  * mapper for `StrictBundles`. */
 export type StrictBundle<T> = T extends ComponentDef ? T : T extends {
     def: ComponentDef<infer S>;
 } ? Bundle<S> : never;
-/** Mapped tuple over a bundle-or-def varargs list — each element re-checked
+/** Mapped tuple over a bundle-or-def varargs list, each element re-checked
  * against its own def's schema. The SolidJS-`on` per-element pattern (pull the
  * tuple apart, map every element), over callable bundles instead of
  * `{ def, values }` entry-objects. The one strictness mechanism shared by
@@ -160,17 +160,18 @@ export type StrictBundles<Items extends readonly BundleOrDef[]> = {
     [K in keyof Items]: StrictBundle<Items[K]>;
 };
 /** Recover the def tuple from a bundle-or-def varargs list, so `template(...)`
- * still returns `Template<[Pos, Vel]>` — the typed key set that `spawn`'s
+ * still returns `Template<[Pos, Vel]>`, the typed key set that `spawn`'s
  * `overrides` (`TemplateOverrides`) maps over. Also a per-element tuple map. */
 export type DefsOf<Items extends readonly BundleOrDef[]> = {
     [K in keyof Items]: Items[K] extends {
         def: infer D extends ComponentDef;
     } ? D : Items[K] extends ComponentDef ? Items[K] : never;
 };
-/** Pair a component def with field values to attach. Omitted fields zero-fill;
- * a tag def takes no values (see `ValuesArg`). */
+/** Pair a component def with field values to attach. Omitted fields zero-fill.
+ * A tag def takes no values (see `ValuesArg`). */
 export declare function bundle<S extends ComponentSchema>(def: ComponentDef<S>, ...values: ValuesArg<S>): Bundle<S>;
-/** Extract the def from a `BundleOrDef`. A bare def is the callable; a bundle a plain object. */
+/** Extract the def from a `BundleOrDef`. A bare def is the callable. A bundle
+ * is a plain object. */
 export declare function bundleDef(item: BundleOrDef): ComponentDef;
 /** Extract the values from a `BundleOrDef` (a bare def contributes no values). */
 export declare function bundleValues(item: BundleOrDef): Readonly<Record<string, number>>;
@@ -180,8 +181,8 @@ export declare function bundleValues(item: BundleOrDef): Readonly<Record<string,
  *
  * **Advisory, not a runtime barrier:** the value behind this type is the live
  * mutable backing `TypedArray` (`Archetype.getColumnRead` returns
- * `.buf as unknown as ReadonlyColumn`), so a §10c-policed cast can still write
- * through. For mutation use the mutable `Archetype.getColumn` (tick-bumping).
+ * `.buf as unknown as ReadonlyColumn`), so a deliberate cast can still write
+ * through. For mutation use the mutable `Archetype.getColumnMut` (tick-bumping).
  * Enforced by the escape-hatch lint, not the runtime.
  */
 export interface ReadonlyColumn {
@@ -190,7 +191,7 @@ export interface ReadonlyColumn {
 }
 /**
  * Compile-time readonly view of a Uint32Array. Blocks index writes at the type
- * layer. **Advisory, not a runtime barrier** — same caveat as `ReadonlyColumn`:
+ * layer. **Advisory, not a runtime barrier**, same caveat as `ReadonlyColumn`:
  * the underlying value is the live mutable buffer.
  */
 export interface ReadonlyUint32Array {

package/dist/core/ecs/component.d.ts

@@ -19,12 +19,12 @@ export type FieldValues<S extends ComponentSchema> = {
     readonly [K in keyof S]: number;
 };
 /**
- * Values argument tuple for attaching a component of schema `S` — empty for a
+ * Values argument tuple for attaching a component of schema `S`, empty for a
  * tag, a single optional partial-values map otherwise. A tag schema
  * (`Record<string, never>`) would otherwise degenerate: `keyof` an
  * index-signature record is `string`, so `Partial<FieldValues<…>>` collapses to
  * `Record<string, number>` and `Frozen({ anything: 1 })` compiles. The
- * conditional forbids values on tags outright; a schema-erased `ComponentDef`
+ * conditional forbids values on tags outright. A schema-erased `ComponentDef`
  * falls into the valued branch, so untyped call sites keep the loose shape.
  */
 export type ValuesArg<S extends ComponentSchema> = S extends Record<string, never> ? [] : [values?: Partial<FieldValues<S>>];
@@ -32,16 +32,16 @@ export type ValuesArg<S extends ComponentSchema> = S extends Record<string, neve
  * `FieldValues` for APIs where the values object is required and complete
  * (`addComponent`'s valued overload, the host-seam `SpawnEntry`). Guards the
  * same tag degeneracy as `ValuesArg`: a tag accepts only the empty object
- * (`Record<string, never>` — every property typed `never`), so
+ * (`Record<string, never>`, every property typed `never`), so
  * `addComponent(e, Frozen, { x: 1 })` is a compile error while the
  * tag-overload-less call sites can still pass `{}`.
  */
 export type CompleteFieldValues<S extends ComponentSchema> = S extends Record<string, never> ? Record<string, never> : FieldValues<S>;
 /**
  * Trailing-argument tuple for the attach surfaces (`ctx.commands.add`'s
- * explicit-values form, `ctx.addSparse`): a tag takes NO values argument, a valued schema REQUIRES a
- * complete one. Encodes the former tag/valued overload pair as one signature,
- * which the typed system seam needs — its `def` parameter is a single
+ * explicit-values form, `ctx.addSparse`): a tag takes no values argument, a valued schema requires a
+ * complete one. Encodes the former tag and valued overload pair as one signature,
+ * which the typed system seam needs, its `def` parameter is a single
  * declared-access-constrained type param, and per-schema overloads would
  * re-introduce the tag-vs-valued split on top of it.
  */
@@ -51,10 +51,10 @@ export type ColumnsForSchema<S extends ComponentSchema> = {
     readonly [K in keyof S]: TagToTypedArray[S[K]];
 };
 /**
- * Mutable sibling of `ColumnsForSchema` — the field-keyed column group handed
- * back by `eachChunk`'s `cols.mut(def)` (no `readonly`, since the whole point
+ * Mutable sibling of `ColumnsForSchema`, the field-keyed column group handed
+ * back by `forEachChunk`'s `cols.mut(def)` (no `readonly`, since the whole point
  * is in-place writes). The change-tick is stamped once when the group is
- * resolved, so the per-row loop is plain typed-array indexing (§eachChunk).
+ * resolved, so the per-row loop is plain typed-array indexing.
  */
 export type MutableColumnsForSchema<S extends ComponentSchema> = {
     [K in keyof S]: TagToTypedArray[S[K]];
@@ -62,28 +62,28 @@ export type MutableColumnsForSchema<S extends ComponentSchema> = {
 declare const __schema: unique symbol;
 /**
  * A component handle. **Callable**: `Pos({ x, y })` produces a `Bundle` (omitted
- * fields zero-fill at attach), so one varargs shape — `spawn(Pos({x,y}),
- * Vel({vx:1}), IsEnemy)` — replaces the older incompatible attach shapes. A bare
- * `Pos` (uncalled) still stands in for a tag / all-zero values wherever a
+ * fields zero-fill at attach), so one varargs shape, `spawn(Pos({x,y}),
+ * Vel({vx:1}), IsEnemy)`, replaces the older incompatible attach shapes. A bare
+ * `Pos` (uncalled) still stands in for a tag, or for all-zero values, wherever a
  * `BundleOrDef` is accepted.
  *
  * The numeric component id lives on `.id` (registration order). Consumers treat
- * the def as an opaque handle; internal code reads `def.id` where it needs the
+ * the def as an opaque handle. Internal code reads `def.id` where it needs the
  * raw id. The call signature's `S` makes `ComponentDef<{x:"f64"}>` distinct from
  * `ComponentDef<{vx:"f64"}>`.
  *
- * The optional `[__schema]` slot never exists at runtime; it re-states `S` in a
- * covariant tuple position so that a TAG def type is not a universal assignment
+ * The optional `[__schema]` slot never exists at runtime. It re-states `S` in a
+ * covariant tuple position so that a tag def type is not a universal assignment
  * sink. Through the call signature alone every def is assignable to
  * `ComponentDef<Record<string, never>>` (the tag callable takes no required
- * args and any `Bundle` satisfies its return), which would let ONE tag in a
+ * args and any `Bundle` satisfies its return), which would let one tag in a
  * system's declared-access union admit every component at compile time
- * (§typestate — `DeclaredRead` and friends in system.ts). With the slot, a
+ * (`DeclaredRead` and friends in system.ts). With the slot, a
  * valued schema is not assignable to the tag schema (`"f64" ⊀ never`), while
  * schema erasure (`ComponentDef<S>` → bare `ComponentDef`) still works because
  * every schema is assignable to `ComponentSchema`.
  *
- * Build one with `makeComponentDef`; never construct by hand.
+ * Build one with `createComponentDef`. Never construct by hand.
  */
 export interface ComponentDef<S extends ComponentSchema = ComponentSchema> {
     (...values: ValuesArg<S>): Bundle<S>;
@@ -92,17 +92,17 @@ export interface ComponentDef<S extends ComponentSchema = ComponentSchema> {
 }
 /**
  * Recover a def's schema type: `SchemaOf<typeof Pos>` is `{x:"f64", y:"f64"}`.
- * The typed `SystemContext` methods (§typestate) constrain their `def`
+ * The typed `SystemContext` methods (system.ts) constrain their `def`
  * parameter to the system's declared-access union and use this to type the
  * field argument, in place of taking `ComponentDef<S>` directly.
  */
 export type SchemaOf<D> = D extends ComponentDef<infer S extends ComponentSchema> ? S : never;
 /**
- * `unknown` if `D` is one of the query's declared terms, else an error tuple —
- * the query-seam sibling of system.ts's `DeclaredRead` (§typestate,
- * POLISH_AUDIT #6). `Query.eachChunk`'s cursor and `ArchetypeView`'s column
+ * `unknown` if `D` is one of the query's declared terms, else an error tuple,
+ * the query-seam sibling of system.ts's `DeclaredRead`.
+ * `Query.forEachChunk`'s cursor and `ArchetypeView`'s column
  * accessors intersect this into their `def` parameter so fetching a component
- * that is NOT a term of the iterating query fails to compile (previously
+ * that is not a term of the iterating query fails to compile (previously
  * caught only by the dev-mode access check, and only when the system's
  * declaration was itself wrong). Same encoding rules as the system asserts:
  * stable `D extends ComponentDef<any>` constraints keep instantiations
@@ -110,15 +110,15 @@ export type SchemaOf<D> = D extends ComponentDef<infer S extends ComponentSchema
  */
 export type DeclaredQueryTerm<Defs extends readonly ComponentDef<any>[], D> = [D] extends [
     Defs[number]
-] ? unknown : ["component is not a term of this query — add it with .and(...)", D];
-/** Options bag accepted by `registerComponent` / `registerSparseComponent`. */
+] ? unknown : ["component is not a term of this query, add it with .and(...)", D];
+/** Options bag accepted by `registerComponent` and `registerSparseComponent`. */
 export interface ComponentRegisterOptions {
-    /** Debug label for diagnostics — errors then read `'Pos' (component 5)`
+    /** Debug label for diagnostics, errors then read `'Pos' (component 5)`
      * instead of `component 5`. Never affects behaviour, layout, or hashing. */
     readonly name?: string;
 }
 /**
- * Schema-erased component handle — just the `.id`. Internal, schema-agnostic
+ * Schema-erased component handle, only the `.id`. Internal, schema-agnostic
  * code (access checks, dirty-set notes, field-id lookup) takes this instead of
  * `ComponentDef`: the callable signature makes `ComponentDef<S>` *invariant* in
  * `S` (a generic `ComponentDef<S>` is not assignable to `ComponentDef`), but
@@ -131,27 +131,27 @@ export type ComponentHandle = {
 /**
  * Mint a callable `ComponentDef` for a freshly-registered component id. The
  * returned function produces a `Bundle` when called (`Pos({x,y})`) and carries
- * its numeric id on a non-enumerable `.id` (invisible to spreads / `JSON`).
- * The single cast bridges the function value to the branded handle type — the
- * `.id` is installed at runtime by `defineProperty` (§10c branded-ID boundary).
+ * its numeric id on a non-enumerable `.id`, invisible to a spread and to `JSON`.
+ * The single cast bridges the function value to the branded handle type, the
+ * `.id` is installed at runtime by `defineProperty` (the branded-ID boundary).
  */
-export declare function makeComponentDef<S extends ComponentSchema>(id: ComponentID): ComponentDef<S>;
+export declare function createComponentDef<S extends ComponentSchema>(id: ComponentID): ComponentDef<S>;
 export interface Bundle<S extends ComponentSchema = ComponentSchema> {
     readonly def: ComponentDef<S>;
     readonly values: Partial<FieldValues<S>>;
 }
-/** Either a populated bundle or a bare def (tag / all-fields-zero). */
+/** Either a populated bundle or a bare def, a tag with all fields zero. */
 export type BundleOrDef<S extends ComponentSchema = ComponentSchema> = Bundle<S> | ComponentDef<S>;
-/** Re-validate one bundle-or-def item against its OWN def's schema. A bare def
- * (the callable) passes as-is; a bundle is re-stated as `Bundle<S>` for its
+/** Re-validate one bundle-or-def item against its own def's schema. A bare def
+ * (the callable) passes as-is. A bundle is re-stated as `Bundle<S>` for its
  * def's `S`, so a hand-written `{ def, values }` literal whose fields don't
- * match the def is rejected — closing the raw-literal leak that `bundle(Pos,…)`
- * / `Pos(…)` never had (those validate at their own call site). Per-element
+ * match the def is rejected, closing the raw-literal leak that `bundle(Pos,…)`
+ * and `Pos(…)` never had (those validate at their own call site). Per-element
  * mapper for `StrictBundles`. */
 export type StrictBundle<T> = T extends ComponentDef ? T : T extends {
     def: ComponentDef<infer S>;
 } ? Bundle<S> : never;
-/** Mapped tuple over a bundle-or-def varargs list — each element re-checked
+/** Mapped tuple over a bundle-or-def varargs list, each element re-checked
  * against its own def's schema. The SolidJS-`on` per-element pattern (pull the
  * tuple apart, map every element), over callable bundles instead of
  * `{ def, values }` entry-objects. The one strictness mechanism shared by
@@ -160,17 +160,18 @@ export type StrictBundles<Items extends readonly BundleOrDef[]> = {
     [K in keyof Items]: StrictBundle<Items[K]>;
 };
 /** Recover the def tuple from a bundle-or-def varargs list, so `template(...)`
- * still returns `Template<[Pos, Vel]>` — the typed key set that `spawn`'s
+ * still returns `Template<[Pos, Vel]>`, the typed key set that `spawn`'s
  * `overrides` (`TemplateOverrides`) maps over. Also a per-element tuple map. */
 export type DefsOf<Items extends readonly BundleOrDef[]> = {
     [K in keyof Items]: Items[K] extends {
         def: infer D extends ComponentDef;
     } ? D : Items[K] extends ComponentDef ? Items[K] : never;
 };
-/** Pair a component def with field values to attach. Omitted fields zero-fill;
- * a tag def takes no values (see `ValuesArg`). */
+/** Pair a component def with field values to attach. Omitted fields zero-fill.
+ * A tag def takes no values (see `ValuesArg`). */
 export declare function bundle<S extends ComponentSchema>(def: ComponentDef<S>, ...values: ValuesArg<S>): Bundle<S>;
-/** Extract the def from a `BundleOrDef`. A bare def is the callable; a bundle a plain object. */
+/** Extract the def from a `BundleOrDef`. A bare def is the callable. A bundle
+ * is a plain object. */
 export declare function bundleDef(item: BundleOrDef): ComponentDef;
 /** Extract the values from a `BundleOrDef` (a bare def contributes no values). */
 export declare function bundleValues(item: BundleOrDef): Readonly<Record<string, number>>;
@@ -180,8 +181,8 @@ export declare function bundleValues(item: BundleOrDef): Readonly<Record<string,
  *
  * **Advisory, not a runtime barrier:** the value behind this type is the live
  * mutable backing `TypedArray` (`Archetype.getColumnRead` returns
- * `.buf as unknown as ReadonlyColumn`), so a §10c-policed cast can still write
- * through. For mutation use the mutable `Archetype.getColumn` (tick-bumping).
+ * `.buf as unknown as ReadonlyColumn`), so a deliberate cast can still write
+ * through. For mutation use the mutable `Archetype.getColumnMut` (tick-bumping).
  * Enforced by the escape-hatch lint, not the runtime.
  */
 export interface ReadonlyColumn {
@@ -190,7 +191,7 @@ export interface ReadonlyColumn {
 }
 /**
  * Compile-time readonly view of a Uint32Array. Blocks index writes at the type
- * layer. **Advisory, not a runtime barrier** — same caveat as `ReadonlyColumn`:
+ * layer. **Advisory, not a runtime barrier**, same caveat as `ReadonlyColumn`:
  * the underlying value is the live mutable buffer.
  */
 export interface ReadonlyUint32Array {

package/dist/core/ecs/component.d.ts.map

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

package/dist/core/ecs/component_registry.d.cts

@@ -0,0 +1,53 @@
+import { ComponentDef, ComponentHandle } from './component.cjs';
+import { ComponentMeta } from './store_types.cjs';
+import { TypedArrayTag } from '../../type_primitives/index.cjs';
+/**
+ * Reject a field named like an accessor's own state (`__cols`, `__row`): a ref
+ * or cursor over the component would shadow its own state with the field, or
+ * the field with its state. `kind` names the storage class in the fault,
+ * either "component" or "sparse component".
+ *
+ * Always on, not `__DEV__` gated. Registration is cold.
+ */
+export declare function assertFieldNamesFree(fieldNames: readonly string[], kind: string): void;
+/**
+ * Reject an `f32` or an `f64` field on a `deterministic: true` world, at
+ * registration. IEEE-754 rounds differently across hosts in the last place. A
+ * float column in a fixed-update path is then a silent per-tick `stateHash`
+ * divergence between client and server, the one thing the determinism opt-in
+ * exists to prevent.
+ *
+ * A world that did not opt in skips the walk and keeps its floats, so the
+ * default path pays nothing. The array shorthand defaults to `f64` and lands
+ * here too, so a deterministic world must pass an explicit integer type.
+ */
+export declare function assertDeterministicFieldTypes(deterministic: boolean, fieldNames: readonly string[], fieldTypes: readonly TypedArrayTag[], kind: string): void;
+/**
+ * Append one component's metadata to `metas` and return its definition.
+ *
+ * The caller guarantees that `metas` is the world's live metadata array and
+ * that nothing else appends to it. The id this hands out is the array's length
+ * before the append.
+ *
+ * The archetype descriptor in the backing carries a fixed-width component
+ * mask, and the module matches archetypes on that mask alone. A component id
+ * past the mask's width would be invisible there, so two archetypes that
+ * differ only in such a component would conflate. This fails instead, and the
+ * fault names `registerSparseComponent` as the remedy, because a sparse
+ * component keeps its own id space and costs no mask bit.
+ *
+ * A rejected registration leaves no partial state. Both checks run before the
+ * id is taken and before the append.
+ */
+export declare function appendComponentMeta<S extends Record<string, TypedArrayTag>>(metas: ComponentMeta[], deterministic: boolean, schema: S, name?: string): ComponentDef<S>;
+/** `'Pos' (component 5)` when the component was registered with a debug name,
+ * else `component 5`, the label diagnostics interpolate. */
+export declare function componentMetaLabel(metas: readonly ComponentMeta[], cid: number): string;
+/**
+ * The field index assigned to `(def, fieldName)` at registration. Indexes are
+ * insertion-order, zero-based, and stable for the lifetime of the world. A
+ * system that passes `(component_id, field_id)` pairs across the WASM FFI
+ * resolves them once, at setup.
+ */
+export declare function fieldIdOfMeta(metas: readonly ComponentMeta[], def: ComponentHandle, fieldName: string): number;
+//# sourceMappingURL=component_registry.d.ts.map

package/dist/core/ecs/component_registry.d.ts

@@ -0,0 +1,53 @@
+import { ComponentDef, ComponentHandle } from './component.js';
+import { ComponentMeta } from './store_types.js';
+import { TypedArrayTag } from '../../type_primitives/index.js';
+/**
+ * Reject a field named like an accessor's own state (`__cols`, `__row`): a ref
+ * or cursor over the component would shadow its own state with the field, or
+ * the field with its state. `kind` names the storage class in the fault,
+ * either "component" or "sparse component".
+ *
+ * Always on, not `__DEV__` gated. Registration is cold.
+ */
+export declare function assertFieldNamesFree(fieldNames: readonly string[], kind: string): void;
+/**
+ * Reject an `f32` or an `f64` field on a `deterministic: true` world, at
+ * registration. IEEE-754 rounds differently across hosts in the last place. A
+ * float column in a fixed-update path is then a silent per-tick `stateHash`
+ * divergence between client and server, the one thing the determinism opt-in
+ * exists to prevent.
+ *
+ * A world that did not opt in skips the walk and keeps its floats, so the
+ * default path pays nothing. The array shorthand defaults to `f64` and lands
+ * here too, so a deterministic world must pass an explicit integer type.
+ */
+export declare function assertDeterministicFieldTypes(deterministic: boolean, fieldNames: readonly string[], fieldTypes: readonly TypedArrayTag[], kind: string): void;
+/**
+ * Append one component's metadata to `metas` and return its definition.
+ *
+ * The caller guarantees that `metas` is the world's live metadata array and
+ * that nothing else appends to it. The id this hands out is the array's length
+ * before the append.
+ *
+ * The archetype descriptor in the backing carries a fixed-width component
+ * mask, and the module matches archetypes on that mask alone. A component id
+ * past the mask's width would be invisible there, so two archetypes that
+ * differ only in such a component would conflate. This fails instead, and the
+ * fault names `registerSparseComponent` as the remedy, because a sparse
+ * component keeps its own id space and costs no mask bit.
+ *
+ * A rejected registration leaves no partial state. Both checks run before the
+ * id is taken and before the append.
+ */
+export declare function appendComponentMeta<S extends Record<string, TypedArrayTag>>(metas: ComponentMeta[], deterministic: boolean, schema: S, name?: string): ComponentDef<S>;
+/** `'Pos' (component 5)` when the component was registered with a debug name,
+ * else `component 5`, the label diagnostics interpolate. */
+export declare function componentMetaLabel(metas: readonly ComponentMeta[], cid: number): string;
+/**
+ * The field index assigned to `(def, fieldName)` at registration. Indexes are
+ * insertion-order, zero-based, and stable for the lifetime of the world. A
+ * system that passes `(component_id, field_id)` pairs across the WASM FFI
+ * resolves them once, at setup.
+ */
+export declare function fieldIdOfMeta(metas: readonly ComponentMeta[], def: ComponentHandle, fieldName: string): number;
+//# sourceMappingURL=component_registry.d.ts.map

package/dist/core/ecs/component_registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component_registry.d.ts","sourceRoot":"","sources":["../../../src/core/ecs/component_registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;KAwBK;AAKL,OAAO,EAGN,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAWtF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC5C,aAAa,EAAE,OAAO,EACtB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,UAAU,EAAE,SAAS,aAAa,EAAE,EACpC,IAAI,EAAE,MAAM,GACV,IAAI,CAiBN;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EAC1E,KAAK,EAAE,aAAa,EAAE,EACtB,aAAa,EAAE,OAAO,EACtB,MAAM,EAAE,CAAC,EACT,IAAI,CAAC,EAAE,MAAM,GACX,YAAY,CAAC,CAAC,CAAC,CAyCjB;AAED;4DAC4D;AAC5D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGvF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,GAAG,EAAE,eAAe,EACpB,SAAS,EAAE,MAAM,GACf,MAAM,CAiBR"}

package/dist/core/ecs/compute_backend.d.cts

@@ -2,19 +2,19 @@ import { Brand } from '../../type_primitives/index.cjs';
 import { StoreLayoutListener } from './store_layout_listener.cjs';
 /**
  * An opaque token identifying one of a backend's entry points (one
- * "backend-system"). The engine **never interprets** it — the backend mints it
+ * "backend-system"). The engine **never interprets** it, the backend mints it
  * and is the only thing that maps it back to a concrete computation. Carried on
  * `SystemConfig.backendHandle` and handed verbatim to `ComputeBackend.run`.
  *
- * Branded so a stray `number` can't be mistaken for a handle; consumers mint
+ * Branded so a stray `number` can't be mistaken for a handle. Consumers mint
  * one by casting (the backend owns the id space, like flecs's `run` function
  * pointer or a small index into the backend's entry table).
  */
 export type BackendSystemHandle = Brand<number, "backend_system_handle">;
 /**
  * The engine-side contract a compute backend implements. Composes
- * `StoreLayoutListener` (the already-clean SAB handshake — `setLayout` is called
- * once on attach to seed the layout and again after every SAB grow/extend) with
+ * `StoreLayoutListener` (the already-clean SAB handshake, `setLayout` is called
+ * once on attach to seed the layout and again after every SAB grow and extend) with
  * a single generic `run` entry point.
  *
  * A backend is attached opt-in via `ECS.attachBackend(backend)`, which also
@@ -25,13 +25,24 @@ export interface ComputeBackend extends StoreLayoutListener {
     /**
      * Execute the backend-system identified by `handle`. Called by the
      * `Schedule` in place of the system's `fn` closure, inside the same
-     * `accessCheck` span — so the system's declared `writes` authorise whatever
+     * `accessCheck` span, so the system's declared `writes` authorise whatever
      * shared-memory columns the backend mutates, exactly as a TS body that calls
      * out to the backend would be authorised today.
      *
-     * `handle` is opaque to the engine; it is one the backend minted and the
+     * `handle` is opaque to the engine. It is one the backend minted and the
      * engine merely round-trips from `SystemConfig.backendHandle`.
+     *
+     * `deltaTime` is the seconds the phase runs with, the same value a TS body
+     * receives. A module body needs it, and it is not in the store bytes, so it
+     * travels as a call argument. `tick` is the world's frame tick, the count of
+     * `update()` calls so far, and it is not in the bytes either. A backend that
+     * stamps its own frame state reads it here rather than counting calls, which
+     * would drift on a frame that runs the phase more than once.
+     *
+     * The engine publishes the descriptor row counts before this call when a
+     * mutation left them stale, so a module that walks the descriptors sees the
+     * live row count of every archetype.
      */
-    run(handle: BackendSystemHandle): void;
+    run(handle: BackendSystemHandle, deltaTime: number, tick: number): void;
 }
 //# sourceMappingURL=compute_backend.d.ts.map