@forgeax/engine-ecs 0.1.26 → 0.1.28

package/src/world-entity-lifecycle.ts

@@ -1,37 +1,24 @@
 // @forgeax/engine-ecs — world-entity-lifecycle: entity lifecycle and hierarchy.
 //
-// Owns entity materialization/retirement plus hierarchy orchestration. Component
-// storage remains in WorldComponentAccess; this module composes its typed
-// relationship mutations into public lifecycle behavior.
+// Owns spawn preflight and hierarchy orchestration. World is the sole state
+// owner; this module composes its typed internal capabilities into those
+// public lifecycle behaviors.
 
-import { err, isRetiredSlot, ok, pack, type Result } from '@forgeax/engine-types';
-import type { Component, ComponentSchema, InputShapeOf, ShapeOf } from './component';
+import { err, ok, pack, type Result } from '@forgeax/engine-types';
+import type { Component, ComponentSchema, InputShapeOf } from './component';
 import { componentId, componentSchema } from './component';
-import { fillComponentDefaults, validateComponentDataKeys } from './component-default-fallback';
 import { expandComponentRequirements } from './component-schema';
-import { validateManagedArrayValues, validateSharedFieldValues } from './component-value-validate';
-import { Entity } from './entity';
-import {
-  ENTITY_NULL_RAW,
-  type EntityHandle,
-  encodeEntity,
-  entityGeneration,
-  entityIndex,
-} from './entity-handle';
+import { ENTITY_NULL_RAW, type EntityHandle, entityGeneration, entityIndex } from './entity-handle';
 import {
   ComponentNotPresentError,
   RelationshipDetachMismatchError,
   RelationshipSelfCycleError,
   StaleEntityError,
-  validateEnumFieldValues,
 } from './errors';
-import { relationshipRole, relationshipSource } from './relationship-index';
-import { type Archetype, appendArchetypeRow, removeArchetypeRow } from './storage/archetype';
+import { relationshipRole } from './relationship-index';
+import type { Archetype } from './storage/archetype';
 import type { ArchetypeGraph } from './storage/archetype-graph';
-import { getOrCreateArchetype, getTable } from './storage/archetype-graph';
-import { removeSparseTag } from './storage/change-detection';
-import { appendTableRow, removeTableRow } from './storage/table';
-import type { EcsError, World } from './world';
+import type { ComponentData, EcsError, World } from './world';
 import { worldInternal } from './world-internal';
 
 function tableRow(world: World, record: { archetypeId: number; archetypeRow: number }): number {
@@ -40,190 +27,23 @@ function tableRow(world: World, record: { archetypeId: number; archetypeRow: num
 }
 
 /**
- * Core implementation of `spawn` with a relationship reentry guard.
- *
- * @param internal - `true` when relationship maintenance creates a mirror.
+ * Core implementation of `spawn`.
  */
 export function spawnCore(
   world: World,
-  componentDatas: { component: Component; data: Partial<Record<string, unknown>> }[],
-  internal: boolean,
+  componentDatas: ComponentData[],
 ): Result<EntityHandle, EcsError> {
   componentDatas = expandComponentRequirements(componentDatas);
-  const filledData: Record<string, unknown>[] = [];
   for (const cd of componentDatas) {
     const preflight = world[worldInternal].preflightComponentData(null, cd);
     if (!preflight.ok) return preflight;
-    const keyErr = validateComponentDataKeys(cd.component, cd.data as Record<string, unknown>);
-    if (keyErr !== null) return err(keyErr as unknown as EcsError);
-    const arrayErr = validateManagedArrayValues(cd.component, cd.data as Record<string, unknown>);
-    if (arrayErr !== null) return err(arrayErr as unknown as EcsError);
-    const sharedErr = validateSharedFieldValues(cd.component, cd.data as Record<string, unknown>);
-    if (sharedErr !== null) return err(sharedErr as unknown as EcsError);
-    const filled = fillComponentDefaults(cd.component, cd.data as Record<string, unknown>);
-    const enumErr = validateEnumFieldValues(cd.component, filled);
-    if (enumErr !== null) return err(enumErr as unknown as EcsError);
-    filledData.push(filled as Record<string, unknown>);
-  }
-  // Reserve every relationship target before allocating the new source row.
-  // In particular, an injected BufferPool failure must not leave a source
-  // entity, mirror component, or mutation epoch behind.
-  const relationshipPreparations: unknown[] = [];
-  if (!internal) {
-    for (let index = 0; index < componentDatas.length; index += 1) {
-      const componentData = componentDatas[index];
-      const value = filledData[index];
-      if (
-        componentData === undefined ||
-        value === undefined ||
-        relationshipRole(componentData.component as Component)?.kind !== 'source'
-      ) {
-        continue;
-      }
-      const prepared = world[worldInternal].prepareRelationshipInsert(
-        componentData.component as Component,
-        value,
-      );
-      if (!prepared.ok) {
-        for (const reservation of relationshipPreparations) {
-          world[worldInternal].releaseRelationshipPreparation(reservation);
-        }
-        return prepared;
-      }
-      relationshipPreparations[index] = prepared.value;
-    }
-  }
-  const indexSlot = world[worldInternal].allocateIndex();
-  const record = world[worldInternal].getRecords()[indexSlot];
-  if (record === undefined)
-    return err(
-      new Error('Internal: allocateIndex did not initialize record') as unknown as EcsError,
-    );
-  const componentIds = componentDatas.map((cd) => componentId(cd.component));
-  const components = componentDatas.map((cd) => cd.component);
-  const graph = world[worldInternal].getGraph();
-  const arch = getOrCreateArchetype(graph, componentIds, components);
-  const table = getTable(graph, arch.tableId);
-  const spawnedEntity = encodeEntity(indexSlot, record.generation);
-  const tableRow = appendTableRow(table, spawnedEntity);
-  const archetypeRow = appendArchetypeRow(arch, tableRow);
-  record.archetypeId = arch.id;
-  record.archetypeRow = archetypeRow;
-  for (let i = 0; i < componentDatas.length; i++) {
-    const cdi = componentDatas[i];
-    const fdi = filledData[i];
-    if (cdi === undefined || fdi === undefined) continue;
-    world[worldInternal].writeRow(arch, cdi.component, tableRow, fdi as ShapeOf<ComponentSchema>);
   }
-  world[worldInternal].writeEntitySelf(arch, tableRow, spawnedEntity);
-  world[worldInternal].markComponentsAdded(spawnedEntity, [
-    componentId(Entity),
-    ...componentDatas.map((cd) => componentId(cd.component)),
-  ]);
-  for (let i = 0; i < componentDatas.length; i++) {
-    const cd = componentDatas[i];
-    const filled = filledData[i];
-    if (!cd || filled === undefined) continue;
-    if (!internal && relationshipRole(cd.component as Component)?.kind === 'source') {
-      const relation = world[worldInternal].relationshipOnInsert(
-        spawnedEntity,
-        cd.component as Component,
-        filled,
-        relationshipPreparations[i],
-      );
-      if (!relation.ok) {
-        for (const reservation of relationshipPreparations) {
-          world[worldInternal].releaseRelationshipPreparation(reservation);
-        }
-        return relation;
-      }
-    }
-  }
-  world[worldInternal].markStructureChanged();
-  world[worldInternal].recordStructuralEvidence({
-    kind: 'spawn',
-    entity: spawnedEntity,
-  });
+  const spawnedEntity = world[worldInternal].allocatePendingEntity();
+  const materialized = world[worldInternal].materializeEntity(spawnedEntity, componentDatas);
+  if (!materialized.ok) return materialized;
   return ok(spawnedEntity);
 }
 
-/**
- * Core implementation of `despawn` with a linked-spawn cascade guard.
- *
- * @param internal - `true` while recursively retiring linked children.
- */
-export function despawnCore(
-  world: World,
-  entity: EntityHandle,
-  internal: boolean,
-): Result<void, EcsError> {
-  const slot = entityIndex(entity);
-  const gen = entityGeneration(entity);
-  const record = world[worldInternal].getRecords()[slot];
-  if (!world[worldInternal].recordIsLive(record, gen)) return ok(undefined);
-  const arch = world[worldInternal].getGraph().archetypes[record?.archetypeId];
-  const linkedChildren = arch ? relationshipLinkedSpawnChildren(world, entity, arch) : [];
-  if (arch) {
-    const graph = world[worldInternal].getGraph();
-    const table = getTable(graph, arch.tableId);
-    const archetypeRow = record.archetypeRow;
-    const tableRow = arch.rows[archetypeRow] ?? 0;
-    for (const comp of arch.components) {
-      const role = relationshipRole(comp);
-      const needsOldValue = role?.kind === 'source' && !internal;
-      if (needsOldValue) {
-        const oldValue = world[worldInternal].readRow(arch, comp, tableRow) as Record<
-          string,
-          unknown
-        >;
-        if (role?.kind === 'source' && !internal) {
-          const relation = world[worldInternal].relationshipOnRemove(entity, comp, oldValue);
-          if (!relation.ok) return relation;
-        }
-      }
-      world[worldInternal].releaseManagedRefsOnRow(arch, comp, tableRow);
-    }
-    for (const component of arch.components) {
-      if (component.storage !== 'sparse') continue;
-      const set = graph.sparseTags.get(componentId(component));
-      if (set !== undefined) removeSparseTag(set, entity);
-    }
-    const archetypeSwap = removeArchetypeRow(arch, archetypeRow);
-    if (archetypeSwap !== null) {
-      const movedEntity = (table.storage.get(componentId(Entity))?.fields.get('self')?.view[
-        archetypeSwap.movedTableRow
-      ] ?? 0) as EntityHandle;
-      const movedRecord = world[worldInternal].getRecords()[entityIndex(movedEntity)];
-      if (movedRecord?.generation === entityGeneration(movedEntity)) {
-        movedRecord.archetypeRow = archetypeSwap.newRow;
-      }
-    }
-    const tableSwap = removeTableRow(table, tableRow);
-    if (tableSwap !== null) {
-      const movedRecord = world[worldInternal].getRecords()[entityIndex(tableSwap.movedEntity)];
-      if (movedRecord?.generation === entityGeneration(tableSwap.movedEntity)) {
-        const movedArchetype = graph.archetypes[movedRecord.archetypeId];
-        if (movedArchetype !== undefined) {
-          movedArchetype.rows[movedRecord.archetypeRow] = tableSwap.newRow;
-        }
-      }
-    }
-  }
-  world[worldInternal].recordStructuralEvidence({
-    kind: 'despawn',
-    entity,
-  });
-  if (record) {
-    record.archetypeId = -1;
-    record.archetypeRow = -1;
-    record.generation += 1;
-    if (!isRetiredSlot(record.generation)) world[worldInternal].getFreeIndices().push(slot);
-  }
-  for (const child of linkedChildren) despawnCore(world, child, true);
-  world[worldInternal].markStructureChanged();
-  return ok(undefined);
-}
-
 /** Attach a child and maintain the relationship mirror through component storage. */
 export function worldAddChild<S extends ComponentSchema>(
   world: World,
@@ -233,39 +53,19 @@ export function worldAddChild<S extends ComponentSchema>(
   data: Partial<InputShapeOf<S>>,
 ): Result<void, EcsError> {
   const holderComp = component as Component;
-  const role = relationshipRole(holderComp);
-  if (role?.kind !== 'source') {
+  if (relationshipRole(holderComp)?.kind !== 'source') {
     return err(new ComponentNotPresentError(child as number, component.name));
   }
 
+  const parentResult = world[worldInternal].lookupAlive(parent, 'addChild', component.name);
+  if (!parentResult.ok) return parentResult;
   const parentSlot = entityIndex(parent);
   const parentGeneration = entityGeneration(parent);
-  const parentRecord = world[worldInternal].getRecords()[parentSlot];
-  if (!world[worldInternal].recordIsLive(parentRecord, parentGeneration)) {
-    return err(
-      new StaleEntityError(parent as number, parentSlot, parentGeneration, {
-        operation: 'addChild',
-        component: component.name,
-        expectedGeneration: parentGeneration,
-        actualGeneration: world[worldInternal].getRecords()[parentSlot]?.generation ?? -1,
-      }),
-    );
-  }
-
+  const childResult = world[worldInternal].lookupAlive(child, 'addChild', component.name);
+  if (!childResult.ok) return childResult;
   const childSlot = entityIndex(child);
-  const childGeneration = entityGeneration(child);
-  const childRecord = world[worldInternal].getRecords()[childSlot];
-  if (!world[worldInternal].recordIsLive(childRecord, childGeneration)) {
-    return err(
-      new StaleEntityError(child as number, childSlot, childGeneration, {
-        operation: 'addChild',
-        component: component.name,
-        expectedGeneration: childGeneration,
-        actualGeneration: world[worldInternal].getRecords()[childSlot]?.generation ?? -1,
-      }),
-    );
-  }
 
+  const role = relationshipRole(holderComp);
   if (child === parent && !(role?.kind === 'source' && role.allowSelf)) {
     return err(new RelationshipSelfCycleError(component.name, child as number, child as number));
   }
@@ -346,13 +146,13 @@ export function worldReparent<S extends ComponentSchema>(
   if (role?.kind !== 'source') {
     return err(new ComponentNotPresentError(child as number, component.name));
   }
-  if (child === newParent && !(role?.kind === 'source' && role.allowSelf)) {
+  if (child === newParent && !role.allowSelf) {
     return err(
       new RelationshipSelfCycleError(component.name, child as number, newParent as number),
     );
   }
   const cycleHit =
-    child === newParent && role?.kind === 'source' && role.allowSelf
+    child === newParent && role.allowSelf
       ? null
       : relationshipChainCycleHit(
           world,
@@ -387,7 +187,7 @@ export function worldReparent<S extends ComponentSchema>(
     [role.sourceField]: newParent,
   } as Partial<InputShapeOf<S>>;
   if (
-    childArch.components.some((candidate) => componentId(candidate) === componentId(holderComp))
+    childArch.components.some((component) => componentId(component) === componentId(holderComp))
   ) {
     // Existing exclusive sources are updated through the same owner-level
     // write barrier as `world.set`; remove+add would expose a partial mirror
@@ -495,8 +295,6 @@ export function worldIterDescendants(world: World, entity: EntityHandle): Iterab
 function descendantChildren(world: World, arch: Archetype, row: number): EntityHandle[] {
   const children: EntityHandle[] = [];
   for (const component of arch.components) {
-    if (!arch.components.some((candidate) => componentId(candidate) === componentId(component)))
-      continue;
     const value = world[worldInternal].readRow(arch, component, row) as Record<string, unknown>;
     for (const [fieldName, fieldType] of Object.entries(componentSchema(component))) {
       if (fieldType !== 'array<entity>') continue;
@@ -559,30 +357,3 @@ function relationshipChainCycleHit(
     currentGeneration = entityGeneration(target);
   }
 }
-
-function linkedSpawnMirrorField(mirror: Component): string | undefined {
-  const source = relationshipSource(mirror);
-  const role = source === undefined ? undefined : relationshipRole(source);
-  return role?.kind === 'source' && role.linkedSpawn ? role.targetField : undefined;
-}
-
-function relationshipLinkedSpawnChildren(
-  world: World,
-  entity: EntityHandle,
-  arch: Archetype,
-): EntityHandle[] {
-  const record = world[worldInternal].getRecords()[entityIndex(entity)];
-  const row = record === undefined ? -1 : tableRow(world, record);
-  const collected: EntityHandle[] = [];
-  for (const component of arch.components) {
-    const mirrorField = linkedSpawnMirrorField(component);
-    if (mirrorField === undefined) continue;
-    const snapshot = world[worldInternal].readRow(arch, component, row) as Record<string, unknown>;
-    const list = snapshot[mirrorField];
-    if (!(list instanceof Uint32Array)) continue;
-    for (const raw of list) {
-      if (raw !== ENTITY_NULL_RAW) collected.push(raw as EntityHandle);
-    }
-  }
-  return collected;
-}

package/src/world-internal-augmentation.d.ts

@@ -0,0 +1,11 @@
+// Source-only type augmentation for ECS owner modules and package-owned tests.
+// This declaration is included in the ECS TypeScript program but is not
+// imported by World, so declaration emit does not make public `world.d.ts`
+// depend on the raw world-internal module.
+import { type WorldInternal, worldInternal } from './world-internal';
+
+declare module './world' {
+  interface World {
+    [worldInternal]: WorldInternal;
+  }
+}

package/src/world-internal.ts

@@ -11,70 +11,121 @@
 // The registry is package-private by convention: no root/advanced export
 // exposes this key, while Symbol.for keeps source/dist and split bundles on
 // one identity.
+import type { Result } from '@forgeax/engine-types';
+import type { BufferPool } from './buffer-pool';
+import type { Component, ComponentSchema, ShapeOf } from './component';
+import type { EntityHandle } from './entity-handle';
+import type { WorldExecutionFault } from './execution/shared-kernel';
+import type { ResourceStore } from './resource';
+import type { Schedule } from './schedule';
+import type { ScheduleToken } from './schedule-token';
+import type { SharedRefStore } from './shared-ref-store';
+import type { Archetype } from './storage/archetype';
+import type { ArchetypeGraph } from './storage/archetype-graph';
+import type { ChangeTicks } from './storage/change-detection';
+import type { StructuralEvidenceRing } from './storage/structural-evidence';
+import type { Table } from './storage/table';
+import type { ClockWriter } from './time';
+import type { ComponentData, EcsError, EntityRecord } from './world';
+
+/** @internal Package-private identity; absent from the public export map. */
 export const worldInternal: unique symbol = Symbol.for(
   'forgeax.ecs.worldInternal',
 ) as unknown as typeof worldInternal;
 
-type InternalName =
-  | 'addComponentCore'
-  | 'allocateIndex'
-  | 'allocatePendingEntity'
-  | 'cancelPendingEntity'
-  | 'despawnCore'
-  | 'getArrayView'
-  | 'getArrayLength'
-  | 'getArrayElement'
-  | 'getFieldValue'
-  | 'getBufferPool'
-  | 'getClockWriter'
-  | 'getComponentChange'
-  | 'getComponentMutationEpoch'
-  | 'getComponentMutationEpochs'
-  | 'getEntityArchetype'
-  | 'getFixedAccumulator'
-  | 'getFreeIndices'
-  | 'getGraph'
-  | 'getMutationEpoch'
-  | 'getQueryRow'
-  | 'getRecords'
-  | 'getRelationshipEpoch'
-  | 'getRelationshipTargetEntities'
-  | 'getResources'
-  | 'getSchedule'
-  | 'getSchedules'
-  | 'getSharedRefs'
-  | 'getStructureEpoch'
-  | 'getStructuralEvidence'
-  | 'getUniqueRefs'
-  | 'lookupAlive'
-  | 'markComponentAdded'
-  | 'markComponentChanged'
-  | 'markComponentRangeChanged'
-  | 'markComponentsAdded'
-  | 'markStructureChanged'
-  | 'materializePendingEntity'
-  | 'nextMutationEpoch'
-  | 'poisonExecution'
-  | 'publishDerivedRange'
-  | 'prepareRelationshipInsert'
-  | 'preflightComponentData'
-  | 'readRow'
-  | 'recordStructuralEvidence'
-  | 'recordIsLive'
-  | 'relationshipOnInsert'
-  | 'relationshipOnRemove'
-  | 'releaseManagedRefsOnRow'
-  | 'releaseRelationshipPreparation'
-  | 'removeComponentCore'
-  | 'routeError'
-  | 'restoreMutationEpoch'
-  | 'setFixedAccumulator'
-  | 'setQueryRow'
-  | 'spawnCore'
-  | 'writeEntitySelf'
-  | 'writeRow';
-
-export type WorldInternal = {
-  // biome-ignore lint/suspicious/noExplicitAny: this closed package-internal seam preserves each method's existing inferred result type.
-  readonly [K in InternalName]: (...args: any[]) => any;
-};
+/**
+ * The one package-internal capability surface owned by World.
+ *
+ * Every member is explicit so an extraction cannot silently widen the seam or
+ * leak an untyped state bag. The symbol itself remains package-private and is
+ * the only route used by query, commands, and lifecycle helpers.
+ */
+/** @internal Raw ECS owner seam; source-relative consumers only. */
+export interface WorldInternal {
+  readonly allocatePendingEntity: () => EntityHandle;
+  readonly cancelPendingEntity: (entity: EntityHandle) => void;
+  readonly getArrayView: (
+    entity: EntityHandle,
+    component: Component,
+    fieldName: string,
+  ) => ArrayLike<number> | undefined;
+  readonly getBufferPool: () => BufferPool;
+  readonly getClockWriter: () => ClockWriter;
+  readonly getComponentChange: (
+    entity: EntityHandle,
+    componentId: number,
+  ) => ChangeTicks | undefined;
+  readonly getComponentMutationEpochs: () => readonly number[];
+  readonly getEntityArchetype: (entity: EntityHandle) => Archetype | undefined;
+  readonly getFixedAccumulator: () => number;
+  readonly getGraph: () => ArchetypeGraph;
+  readonly getMutationEpoch: () => number;
+  readonly getQueryRow: (
+    entity: EntityHandle,
+    component: Component,
+  ) => Result<Record<string, unknown>, EcsError>;
+  readonly getRecords: () => EntityRecord[];
+  readonly getRelationshipEpoch: (component: Component) => number;
+  readonly getRelationshipTargetEntities: (
+    component: Component,
+    target: EntityHandle,
+  ) => readonly EntityHandle[];
+  readonly getResources: () => ResourceStore;
+  readonly getSchedule: (token: ScheduleToken) => Schedule | undefined;
+  readonly getSchedules: () => ReadonlyMap<ScheduleToken, Schedule>;
+  readonly getSharedRefs: () => SharedRefStore;
+  readonly getStructureEpoch: () => number;
+  readonly getStructuralEvidence: () => StructuralEvidenceRing;
+  readonly lookupAlive: (
+    entity: EntityHandle,
+    operation: string,
+    component?: string,
+  ) => Result<EntityRecord, EcsError>;
+  readonly markComponentChanged: (entity: EntityHandle, componentId: number) => void;
+  readonly markComponentRangeChanged: (
+    table: Table,
+    componentId: number,
+    rowStart: number,
+    rowCount: number,
+  ) => void;
+  readonly materializeEntity: (
+    entity: EntityHandle,
+    componentDatas: ComponentData[],
+  ) => Result<void, EcsError>;
+  readonly materializePendingEntity: (
+    entity: EntityHandle,
+    componentDatas: ComponentData[],
+  ) => Result<void, EcsError>;
+  readonly nextMutationEpoch: () => number;
+  readonly poisonExecution: (fault: WorldExecutionFault) => void;
+  readonly publishDerivedRange: (
+    table: Table,
+    componentId: number,
+    rowStart: number,
+    rowCount: number,
+    epoch: number,
+  ) => void;
+  readonly preflightComponentData: (
+    holder: EntityHandle | null,
+    componentData: ComponentData,
+    pendingEntities?: ReadonlySet<number>,
+    unavailableEntities?: ReadonlySet<number>,
+  ) => Result<void, EcsError>;
+  readonly readRow: <S extends ComponentSchema>(
+    archetype: Archetype,
+    component: Component<string, S>,
+    row: number,
+  ) => ShapeOf<S>;
+  readonly recordIsLive: (
+    record: EntityRecord | undefined,
+    generation: number,
+  ) => record is EntityRecord;
+  readonly routeError: (error: unknown, context?: { readonly systemName: string }) => void;
+  readonly restoreMutationEpoch: (epoch: number) => void;
+  readonly setFixedAccumulator: (value: number) => void;
+  readonly setQueryRow: (
+    entity: EntityHandle,
+    component: Component,
+    value: Record<string, unknown>,
+  ) => Result<void, EcsError>;
+}

package/src/world-read.ts

@@ -0,0 +1,38 @@
+// @forgeax/engine-ecs — safe read-only World seam.
+//
+// This is the only cross-package World capability needed by relationship and
+// scene projections. It exposes semantic scalar/array reads, never the table,
+// archetype, buffer-pool, or mutation stores behind those reads.
+
+import type { Component } from './component';
+import type { EntityHandle } from './entity-handle';
+
+/** Stable identity for the World-owned semantic read capability. */
+export const worldRead: unique symbol = Symbol.for(
+  'forgeax.ecs.worldRead',
+) as unknown as typeof worldRead;
+
+/**
+ * Read-only semantic probes used by owner packages such as scene.
+ *
+ * Missing entities, components, fields, and out-of-range elements return
+ * `undefined`; callers never receive a storage object or mutable view.
+ */
+export interface WorldRead {
+  readonly getFieldValue: (
+    entity: EntityHandle,
+    component: Component,
+    fieldName: string,
+  ) => number | undefined;
+  readonly getArrayLength: (
+    entity: EntityHandle,
+    component: Component,
+    fieldName: string,
+  ) => number | undefined;
+  readonly getArrayElement: (
+    entity: EntityHandle,
+    component: Component,
+    fieldName: string,
+    index: number,
+  ) => number | undefined;
+}

package/src/world-scheduling.ts

@@ -1,6 +1,5 @@
 // @forgeax/engine-ecs -- World schedule and resource orchestration.
 
-import type { Handle } from '@forgeax/engine-types';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import type { CommandBufferImpl } from './commands';
 import {
@@ -472,28 +471,3 @@ export function worldScheduleUsesComponent(world: World, component: object): boo
   }
   return false;
 }
-
-export function worldAllocUniqueRef<Target extends string, T>(
-  world: World,
-  target: Target,
-  payload: T,
-  onRelease?: (payload: T) => void,
-): Handle<Target, 'unique'> {
-  return world[worldInternal].getUniqueRefs().alloc(target, payload, onRelease);
-}
-
-export function worldAllocSharedRef<Target extends string, T>(
-  world: World,
-  target: Target,
-  payload: T,
-): Handle<Target, 'shared'> {
-  return world[worldInternal].getSharedRefs().alloc(target, payload);
-}
-
-export function worldInternSharedRef<Target extends string, T extends object>(
-  world: World,
-  target: Target,
-  payload: T,
-): Handle<Target, 'shared'> {
-  return world[worldInternal].getSharedRefs().intern(target, payload);
-}