@forgeax/engine-ecs 0.1.33 → 0.1.34

package/dist/index.mjs

@@ -1591,240 +1591,6 @@ function createWorldClock(policy) {
     writer: { time, fixed }
   };
 }
-var SIZE_CLASSES = Object.freeze([
-  16,
-  64,
-  256,
-  1024,
-  4096,
-  16384,
-  65536,
-  262144
-]);
-var HAS_TRANSFER = typeof ArrayBuffer.prototype.transfer === "function";
-function bucketIndex(byteLength) {
-  if (byteLength === 0) return -1;
-  for (let i = 0; i < SIZE_CLASSES.length; i++) {
-    const b = SIZE_CLASSES[i];
-    if (b !== void 0 && byteLength <= b) return i;
-  }
-  return SIZE_CLASSES.length;
-}
-var BufferPool = class {
-  slots = /* @__PURE__ */ new Map();
-  /**
-   * Per-bucket free-lists: `freeBuckets[i]` is a LIFO stack of slot ids
-   * whose backing buffer is parked on bucket `i`. Released slots stay on
-   * their original bucket's free-list - v1 never moves a slot between
-   * buckets on release (D-7 no trim).
-   */
-  freeBuckets = SIZE_CLASSES.map(() => []);
-  nextId = 1;
-  /**
-   * Allocate a managed buffer slot of at least `byteLength` bytes.
-   *
-   * Routes:
-   *   - invalid byteLength -> structured out-of-bounds error.
-   *   - byteLength == 0 -> ok({ id, view: zero-length Uint8Array }) (no bucket).
-   *   - byteLength <= 262144 -> ok({ id, view }), bucket = smallest >= byteLength.
-   *   - byteLength > 262144 -> a dedicated allocation; allocation failure is structured.
-   *
-   * D-5: size classes are radix-4 (16 / 64 / 256 / 1K / 4K / 16K / 64K / 256K).
-   * Free-list pop reuses the most recently released slot id at the same bucket;
-   * miss falls through to a fresh allocation.
-   */
-  alloc(byteLength) {
-    if (byteLength === 0) {
-      const id2 = this.nextId++;
-      const buffer2 = new ArrayBuffer(0);
-      const view2 = new Uint8Array(buffer2);
-      this.slots.set(id2, { sizeClassIdx: -1, buffer: buffer2, view: view2, byteLength: 0, live: true });
-      return ok({ id: id2, view: view2 });
-    }
-    if (!Number.isSafeInteger(byteLength) || byteLength < 0) {
-      return err(new ManagedBufferOutOfBoundsError(byteLength, 0));
-    }
-    const idx = bucketIndex(byteLength);
-    if (idx === SIZE_CLASSES.length) {
-      try {
-        const buffer2 = new ArrayBuffer(byteLength);
-        const view2 = new Uint8Array(buffer2);
-        const id2 = this.nextId++;
-        this.slots.set(id2, { sizeClassIdx: idx, buffer: buffer2, view: view2, byteLength, live: true });
-        return ok({ id: id2, view: view2 });
-      } catch {
-        return err(new ManagedBufferOutOfBoundsError(byteLength, 0));
-      }
-    }
-    const bucketBytes = SIZE_CLASSES[idx];
-    if (bucketBytes === void 0) {
-      return err(new ManagedBufferOutOfBoundsError(byteLength, 0));
-    }
-    const free = this.freeBuckets[idx];
-    if (free !== void 0 && free.length > 0) {
-      const id2 = free.pop();
-      const slot = this.slots.get(id2);
-      if (slot === void 0) {
-        return err(new ManagedBufferOutOfBoundsError(byteLength, 0));
-      }
-      slot.byteLength = byteLength;
-      slot.view = new Uint8Array(slot.buffer, 0, byteLength);
-      slot.live = true;
-      new Uint8Array(slot.buffer).fill(0);
-      return ok({ id: id2, view: slot.view });
-    }
-    const id = this.nextId++;
-    const buffer = new ArrayBuffer(bucketBytes);
-    const view = new Uint8Array(buffer, 0, byteLength);
-    this.slots.set(id, {
-      sizeClassIdx: idx,
-      buffer,
-      view,
-      byteLength,
-      live: true
-    });
-    return ok({ id, view });
-  }
-  /**
-   * Grow slot `id` to `newBytes`. Returns the post-grow Uint8Array view.
-   *
-   * Routes (D-6 / D-7):
-   *   - newBytes < current  -> err(managed-buffer-shrink-not-supported).
-   *   - newBytes == current -> ok(current view) (no-op, identity preserved).
-   *   - newBytes > current && same bucket -> ok(re-sliced view) (no transfer).
-   *   - newBytes > current && cross bucket -> ok(new view) backed by a fresh
-   *     bucket buffer; the prior ArrayBuffer is detached via transfer (ES2024)
-   *     or replaced via allocate-and-copy fallback. Old `view`s captured by
-   *     the caller become detached / orphaned - callers must use `pool.view(id)`
-   *     after grow to read the refreshed view (the `release` loop refreshes
-   *     automatically).
-   *   - newBytes beyond the last pooled class -> dedicated allocation.
-   */
-  grow(id, newBytes) {
-    const slot = this.slots.get(id);
-    if (slot === void 0) {
-      return err(new ManagedBufferOutOfBoundsError(newBytes, 0));
-    }
-    if (newBytes < slot.byteLength) {
-      return err(new ManagedBufferShrinkNotSupportedError(newBytes, slot.byteLength));
-    }
-    if (newBytes === slot.byteLength) {
-      return ok(slot.view);
-    }
-    if (!Number.isSafeInteger(newBytes) || newBytes < 0) {
-      return err(new ManagedBufferOutOfBoundsError(newBytes, slot.buffer.byteLength));
-    }
-    const newIdx = bucketIndex(newBytes);
-    if (newBytes <= slot.buffer.byteLength) {
-      slot.byteLength = newBytes;
-      slot.view = new Uint8Array(slot.buffer, 0, newBytes);
-      return ok(slot.view);
-    }
-    const newBucketBytes = SIZE_CLASSES[newIdx] ?? Math.max(newBytes, slot.buffer.byteLength * 2);
-    const oldByteLength = slot.byteLength;
-    let nextBuffer;
-    try {
-      if (HAS_TRANSFER) {
-        nextBuffer = slot.buffer.transfer(newBucketBytes);
-      } else {
-        nextBuffer = new ArrayBuffer(newBucketBytes);
-        new Uint8Array(nextBuffer).set(new Uint8Array(slot.buffer, 0, oldByteLength));
-      }
-    } catch {
-      return err(new ManagedBufferOutOfBoundsError(newBytes, slot.buffer.byteLength));
-    }
-    slot.sizeClassIdx = newIdx;
-    slot.buffer = nextBuffer;
-    slot.byteLength = newBytes;
-    slot.view = new Uint8Array(nextBuffer, 0, newBytes);
-    return ok(slot.view);
-  }
-  /**
-   * Release slot `id` back to its bucket's free-list. Releasing an unknown id
-   * is a no-op - World's release loop drives this and idempotency keeps the
-   * despawn chain free of bookkeeping noise. Bucket free-lists are NEVER
-   * trimmed in v1 (D-7 no trim).
-   */
-  release(id) {
-    const slot = this.slots.get(id);
-    if (slot === void 0) return ok(void 0);
-    if (!slot.live) return ok(void 0);
-    slot.live = false;
-    if (slot.sizeClassIdx >= 0 && slot.sizeClassIdx < SIZE_CLASSES.length) {
-      const bucket = this.freeBuckets[slot.sizeClassIdx];
-      if (bucket !== void 0) bucket.push(id);
-    } else {
-      this.slots.delete(id);
-    }
-    return ok(void 0);
-  }
-  /**
-   * Return the live view for slot `id`. Used by World after `grow` to
-   * refresh the column's stored view reference. Returns a zero-length view
-   * for unknown / released ids so callers never crash on use-after-release.
-   */
-  view(id) {
-    const slot = this.slots.get(id);
-    if (slot === void 0 || !slot.live) return new Uint8Array(0);
-    return slot.view;
-  }
-  /**
-   * Return the bucket-rounded byte capacity for slot `id` --- i.e.
-   * `SIZE_CLASSES[slot.sizeClassIdx]`. Used by managed-buffer view callers
-   * (D-4 no-cache: re-queried per accessor). Returns `0` for the zero-length
-   * (`alloc(0)`) slot; returns `0` for unknown / released ids (mirrors
-   * `view(id)` use-after-release semantics).
-   */
-  byteCapacity(id) {
-    const slot = this.slots.get(id);
-    if (slot === void 0 || !slot.live) return 0;
-    if (slot.sizeClassIdx < 0) return 0;
-    return slot.buffer.byteLength;
-  }
-  /**
-   * Reset the logical byteLength of slot `id` to `newByteLength` while
-   * keeping the same bucket allocation (no transfer, no release). Only
-   * legal when `newByteLength <= bucketBytes`; the slot's bucket index
-   * does not move (D-7 v1 forbids cross-bucket shrink). Used by managed-
-   * buffer clear paths so the slot retains its `byteCapacity` while the
-   * live view becomes zero-length. Bytes past the new logical length are
-   * zero-filled defensively.
-   *
-   * Returns `err(ManagedBufferShrinkNotSupportedError)` when called on a
-   * `sizeClassIdx === -1` slot (alloc(0)) with `newByteLength > 0`, or
-   * when `newByteLength` exceeds the bucket capacity.
-   */
-  setLogicalLength(id, newByteLength) {
-    const slot = this.slots.get(id);
-    if (slot === void 0) {
-      return err(new ManagedBufferOutOfBoundsError(newByteLength, 0));
-    }
-    if (slot.sizeClassIdx < 0) {
-      if (newByteLength === 0) {
-        slot.byteLength = 0;
-        slot.view = new Uint8Array(slot.buffer);
-        return ok(slot.view);
-      }
-      return err(new ManagedBufferOutOfBoundsError(newByteLength, 0));
-    }
-    const bucketBytes = slot.buffer.byteLength;
-    if (newByteLength > bucketBytes) {
-      return err(new ManagedBufferOutOfBoundsError(newByteLength, bucketBytes));
-    }
-    if (newByteLength < slot.byteLength) {
-      new Uint8Array(slot.buffer, newByteLength, slot.byteLength - newByteLength).fill(0);
-    }
-    slot.byteLength = newByteLength;
-    slot.view = new Uint8Array(slot.buffer, 0, newByteLength);
-    return ok(slot.view);
-  }
-  /** @internal Diagnostic count of live slots. Exposed for tests + inspector. */
-  _liveCount() {
-    let n = 0;
-    for (const s of this.slots.values()) if (s.live) n += 1;
-    return n;
-  }
-};
 var ENTITY_MAX_INDEX = MAX_SLOT;
 var ENTITY_MAX_GENERATION = MAX_GEN;
 var ENTITY_NULL_RAW = 4294967295;
@@ -1841,112 +1607,10 @@ function entityGeneration(entity) {
   return unpackGen(entity);
 }
 
-// src/component-default-fallback.ts
-function typeDefault(fieldType) {
-  if (fieldType === "bool") return false;
-  if (fieldType === "entity") return ENTITY_NULL_RAW;
-  if (fieldType === "array<entity>") return [];
-  return 0;
-}
-function fillComponentDefaults(token, raw) {
-  const schema = componentSchema(token);
-  const layer2 = componentDefinition(token).defaults;
-  const out = /* @__PURE__ */ Object.create(null);
-  const rawObj = raw ?? void 0;
-  for (const fieldName of Object.keys(schema)) {
-    const fieldType = schema[fieldName];
-    if (fieldType === void 0) continue;
-    if (rawObj !== void 0 && fieldName in rawObj) {
-      out[fieldName] = rawObj[fieldName];
-      continue;
-    }
-    if (layer2 !== void 0 && fieldName in layer2) {
-      out[fieldName] = layer2[fieldName];
-      continue;
-    }
-    out[fieldName] = typeDefault(fieldType);
-  }
-  return out;
-}
-function validateComponentDataKeys(token, raw) {
-  if (raw === void 0) return null;
-  const schema = componentSchema(token);
-  const rawObj = raw;
-  for (const fieldName of Object.keys(rawObj)) {
-    if (!(fieldName in schema)) {
-      return new SpawnDataUnknownFieldError(token.name, fieldName, Object.keys(schema));
-    }
-  }
-  return null;
-}
-
-// src/component-value-validate.ts
-function isNumericHandle(v) {
-  return typeof v === "number";
-}
-function isSharedScalarType(fieldType) {
-  return fieldType.startsWith("shared<") && fieldType.endsWith(">");
-}
-function isSharedArrayType(fieldType) {
-  if (!fieldType.startsWith("array<") || !fieldType.endsWith(">")) return false;
-  const inner = fieldType.slice(6, -1);
-  const head = inner.indexOf(",") === -1 ? inner : inner.slice(0, inner.indexOf(",")).trim();
-  return head.startsWith("shared<") && head.endsWith(">");
-}
-function isArrayPayload(value) {
-  if (Array.isArray(value)) return true;
-  return ArrayBuffer.isView(value) && typeof value.length === "number";
-}
-function validateManagedArrayValues(token, raw) {
-  if (raw === void 0) return null;
-  const fields = componentDefinition(token).fields;
-  const rawObj = raw;
-  for (const fieldName of Object.keys(rawObj)) {
-    const reflection = fields[fieldName];
-    if (reflection?.arrayMeta === void 0) continue;
-    const value = rawObj[fieldName];
-    if (value === 0) continue;
-    if (value === void 0 || value === null || isArrayPayload(value)) continue;
-    return new ManagedArrayInvalidValueError(token.name, fieldName, reflection.type, value);
-  }
-  return null;
-}
-function validateSharedFieldValues(token, raw) {
-  if (raw === void 0) return null;
-  const schema = componentSchema(token);
-  const rawObj = raw;
-  for (const fieldName of Object.keys(rawObj)) {
-    const fieldType = schema[fieldName];
-    if (fieldType === void 0) continue;
-    const value = rawObj[fieldName];
-    if (value === void 0 || value === null) continue;
-    if (isSharedScalarType(fieldType)) {
-      if (!isNumericHandle(value)) {
-        return new SharedFieldInvalidValueError(token.name, fieldName, fieldType, value);
-      }
-    } else if (isSharedArrayType(fieldType)) {
-      if (!Array.isArray(value)) continue;
-      for (let i = 0; i < value.length; i++) {
-        const el = value[i];
-        if (el === void 0 || el === null) continue;
-        if (!isNumericHandle(el)) {
-          return new SharedFieldInvalidValueError(token.name, fieldName, fieldType, el, i);
-        }
-      }
-    }
-  }
-  return null;
-}
-
-// src/internal.ts
-var DERIVED_WRITER = /* @__PURE__ */ Symbol.for(
-  "forgeax.ecs.query.derivedWriter"
-);
-
-// src/storage/archetype.ts
-var INITIAL_CAPACITY = 64;
-function archetypeKey(componentIds) {
-  return [...foldEssentials(componentIds)].sort((a, b) => a - b).join("+");
+// src/storage/archetype.ts
+var INITIAL_CAPACITY = 64;
+function archetypeKey(componentIds) {
+  return [...foldEssentials(componentIds)].sort((a, b) => a - b).join("+");
 }
 function createArchetype(components, id, tableId) {
   const byId = /* @__PURE__ */ new Map();
@@ -2014,7 +1678,7 @@ function createColumn(fieldType, capacity, arity = 1, shared = false) {
   const view = createFieldView(Ctor, buffer);
   return { buffer, view, capacity, fieldType, arity };
 }
-var HAS_TRANSFER2 = typeof ArrayBuffer.prototype.transfer === "function";
+var HAS_TRANSFER = typeof ArrayBuffer.prototype.transfer === "function";
 function growColumn(col, newCapacity) {
   const meta = TYPE_METADATA[col.fieldType];
   if (!meta) throw new Error(`Missing TYPE_METADATA entry for scalar field type ${col.fieldType}`);
@@ -2028,7 +1692,7 @@ function growColumn(col, newCapacity) {
   if (isSharedBuffer(col.buffer)) {
     buffer = new SharedArrayBuffer(newByteLength);
     new Uint8Array(buffer).set(new Uint8Array(col.buffer));
-  } else if (HAS_TRANSFER2) {
+  } else if (HAS_TRANSFER) {
     buffer = col.buffer.transfer(
       newByteLength
     );
@@ -2066,7 +1730,7 @@ function canonicalComponents(components) {
   for (const component of components) byId.set(componentId(component), component);
   return [...byId.values()].sort((a, b) => componentId(a) - componentId(b));
 }
-function createTable(components, id, shared = false) {
+function createTable(components, id, shared = false, activeDirectories = [/* @__PURE__ */ new Set()]) {
   const sortedComponents = canonicalComponents(components);
   const capacity = INITIAL_CAPACITY2;
   const storage = /* @__PURE__ */ new Map();
@@ -2110,19 +1774,26 @@ function createTable(components, id, shared = false) {
     storage,
     size: 0,
     capacity,
-    version: 0
+    version: 0,
+    membership: new Float64Array(Math.ceil(capacity / PROJECTION_BLOCK_SIZE)),
+    activeDirectories
   };
 }
-function appendTableRow(table, entity) {
+function appendTableRow(table, entity, epoch = 0) {
   if (table.size === table.capacity) growTable(table, table.capacity * 2);
   const row = table.size;
   const self = table.storage.get(componentId(Entity))?.fields.get("self");
   if (self !== void 0) self.view[row] = entity;
   table.size = row + 1;
+  if (row === 0) for (const directory of table.activeDirectories) directory.add(table);
+  markTableMembership(table, row, epoch);
   return row;
 }
-function removeTableRow(table, row) {
+function removeTableRow(table, row, epoch = 0) {
   const lastRow = table.size - 1;
+  markTableMembership(table, row, epoch);
+  markTableMembership(table, lastRow, epoch);
+  if (lastRow === 0) for (const directory of table.activeDirectories) directory.delete(table);
   if (row === lastRow) {
     table.size = lastRow;
     return null;
@@ -2150,9 +1821,15 @@ function growTable(table, targetCapacity) {
     componentStorage.fields = fields;
     componentStorage.epochs = growComponentEpochColumns(componentStorage.epochs, capacity);
   }
+  const membership = new Float64Array(Math.ceil(capacity / PROJECTION_BLOCK_SIZE));
+  membership.set(table.membership);
+  table.membership = membership;
   table.capacity = capacity;
   table.version += 1;
 }
+function markTableMembership(table, row, epoch) {
+  table.membership[Math.floor(row / PROJECTION_BLOCK_SIZE)] = epoch;
+}
 
 // src/storage/archetype-graph.ts
 function createArchetypeGraph(shared = false) {
@@ -2161,6 +1838,8 @@ function createArchetypeGraph(shared = false) {
     dedupByKey: /* @__PURE__ */ new Map(),
     generation: 0,
     tables: [],
+    activeTables: /* @__PURE__ */ new Set(),
+    activeTablesByComponent: /* @__PURE__ */ new Map(),
     tableDedupByKey: /* @__PURE__ */ new Map(),
     tableGeneration: 0,
     sparseTags: /* @__PURE__ */ new Map(),
@@ -2179,7 +1858,17 @@ function getOrCreateTable(graph, components) {
   const key = tableKey(tableComponents.map((component) => componentId(component)));
   const existingId = graph.tableDedupByKey.get(key);
   if (existingId !== void 0) return getTable(graph, existingId);
-  const table = createTable(tableComponents, graph.tables.length, graph.shared);
+  const directories = [graph.activeTables];
+  for (const component of tableComponents) {
+    const id = componentId(component);
+    let directory = graph.activeTablesByComponent.get(id);
+    if (directory === void 0) {
+      directory = /* @__PURE__ */ new Set();
+      graph.activeTablesByComponent.set(id, directory);
+    }
+    directories.push(directory);
+  }
+  const table = createTable(tableComponents, graph.tables.length, graph.shared, directories);
   graph.tables.push(table);
   graph.tableDedupByKey.set(key, table.id);
   graph.tableGeneration += 1;
@@ -2215,164 +1904,523 @@ function getAddEdge(graph, src, componentId2, component) {
       return target2;
     }
   }
-  const newIds = [...src.components.map((c) => componentId(c)), componentId2];
-  const newComponents = [...src.components, component];
-  const target = getOrCreateArchetype(graph, newIds, newComponents);
-  src.addEdges.set(componentId2, target.id);
-  return target;
+  const newIds = [...src.components.map((c) => componentId(c)), componentId2];
+  const newComponents = [...src.components, component];
+  const target = getOrCreateArchetype(graph, newIds, newComponents);
+  src.addEdges.set(componentId2, target.id);
+  return target;
+}
+function getRemoveEdge(graph, src, componentId2) {
+  const cached = src.removeEdges.get(componentId2);
+  if (cached !== void 0) {
+    const target2 = graph.archetypes[cached];
+    if (target2) {
+      return target2;
+    }
+  }
+  const newIds = src.components.map((c) => componentId(c)).filter((id) => id !== componentId2);
+  const newComponents = src.components.filter((c) => componentId(c) !== componentId2);
+  const target = getOrCreateArchetype(graph, newIds, newComponents);
+  src.removeEdges.set(componentId2, target.id);
+  return target;
+}
+
+// src/storage/change-detection.ts
+var PROJECTION_BLOCK_SIZE = 256;
+var INITIAL_SPARSE_CAPACITY = 64;
+function createComponentEpochColumns(capacity) {
+  return {
+    added: new Float64Array(capacity),
+    changed: new Float64Array(capacity),
+    blocks: new Float64Array(Math.ceil(capacity / PROJECTION_BLOCK_SIZE))
+  };
+}
+function growComponentEpochColumns(columns, capacity) {
+  const added = new Float64Array(capacity);
+  const changed = new Float64Array(capacity);
+  added.set(columns.added);
+  changed.set(columns.changed);
+  const blocks = new Float64Array(Math.ceil(capacity / PROJECTION_BLOCK_SIZE));
+  blocks.set(columns.blocks);
+  return { added, changed, blocks };
+}
+function copyComponentEpoch(source, sourceRow, target, targetRow) {
+  target.added[targetRow] = source.added[sourceRow] ?? 0;
+  target.changed[targetRow] = source.changed[sourceRow] ?? 0;
+  const block = Math.floor(targetRow / PROJECTION_BLOCK_SIZE);
+  target.blocks[block] = Math.max(target.blocks[block] ?? 0, target.changed[targetRow] ?? 0);
+}
+function createSparseTagSet(component) {
+  const sparse = new Int32Array(INITIAL_SPARSE_CAPACITY);
+  sparse.fill(-1);
+  return {
+    component,
+    sparse,
+    dense: new Uint32Array(INITIAL_SPARSE_CAPACITY),
+    added: new Float64Array(INITIAL_SPARSE_CAPACITY),
+    changed: new Float64Array(INITIAL_SPARSE_CAPACITY),
+    size: 0
+  };
+}
+function sparseTagIndex(set, entity) {
+  const denseIndex = set.sparse[entityIndex(entity)] ?? -1;
+  return denseIndex >= 0 && set.dense[denseIndex] === entity ? denseIndex : -1;
+}
+function insertSparseTag(set, entity, epoch) {
+  const present = sparseTagIndex(set, entity);
+  if (present >= 0) {
+    set.changed[present] = epoch;
+    return present;
+  }
+  growSparseSlots(set, entityIndex(entity) + 1);
+  if (set.size === set.dense.length) growSparseDense(set, set.size + 1);
+  const denseIndex = set.size;
+  set.dense[denseIndex] = entity;
+  set.added[denseIndex] = epoch;
+  set.changed[denseIndex] = epoch;
+  set.sparse[entityIndex(entity)] = denseIndex;
+  set.size += 1;
+  return denseIndex;
+}
+function removeSparseTag(set, entity) {
+  const denseIndex = sparseTagIndex(set, entity);
+  if (denseIndex < 0) return false;
+  const lastIndex = set.size - 1;
+  set.sparse[entityIndex(entity)] = -1;
+  if (denseIndex !== lastIndex) {
+    const movedEntity = set.dense[lastIndex];
+    set.dense[denseIndex] = movedEntity;
+    set.added[denseIndex] = set.added[lastIndex] ?? 0;
+    set.changed[denseIndex] = set.changed[lastIndex] ?? 0;
+    set.sparse[entityIndex(movedEntity)] = denseIndex;
+  }
+  set.size = lastIndex;
+  return true;
+}
+function growSparseSlots(set, targetCapacity) {
+  if (targetCapacity <= set.sparse.length) return;
+  let capacity = set.sparse.length;
+  while (capacity < targetCapacity) capacity *= 2;
+  const sparse = new Int32Array(capacity);
+  sparse.fill(-1);
+  sparse.set(set.sparse);
+  set.sparse = sparse;
+}
+function growSparseDense(set, targetCapacity) {
+  let capacity = set.dense.length;
+  while (capacity < targetCapacity) capacity *= 2;
+  const dense = new Uint32Array(capacity);
+  dense.set(set.dense);
+  set.dense = dense;
+  const added = new Float64Array(capacity);
+  added.set(set.added);
+  set.added = added;
+  const changed = new Float64Array(capacity);
+  changed.set(set.changed);
+  set.changed = changed;
+}
+function readComponentChange(graph, location, entity, componentId2) {
+  const sparseSet = graph.sparseTags.get(componentId2);
+  if (sparseSet !== void 0) {
+    const denseIndex = sparseTagIndex(sparseSet, entity);
+    if (denseIndex < 0) return void 0;
+    return {
+      added: sparseSet.added[denseIndex] ?? 0,
+      changed: sparseSet.changed[denseIndex] ?? 0
+    };
+  }
+  const archetype = graph.archetypes[location.archetypeId];
+  if (archetype === void 0) return void 0;
+  const epochs = graph.tables[archetype.tableId]?.storage.get(componentId2)?.epochs;
+  if (epochs === void 0) return void 0;
+  const tableRow2 = archetype.rows[location.archetypeRow] ?? -1;
+  return {
+    added: epochs.added[tableRow2] ?? 0,
+    changed: epochs.changed[tableRow2] ?? 0
+  };
+}
+function markComponentsAdded(graph, location, entity, componentIds, epoch) {
+  const archetype = graph.archetypes[location.archetypeId];
+  const table = archetype === void 0 ? void 0 : graph.tables[archetype.tableId];
+  const tableRow2 = archetype?.rows[location.archetypeRow] ?? -1;
+  for (const componentId2 of componentIds) {
+    const component = archetype?.components.find(
+      (candidate) => componentId(candidate) === componentId2
+    );
+    if (component?.storage === "sparse") {
+      insertSparseTag(getOrCreateSparseTagSet(graph, component), entity, epoch);
+      continue;
+    }
+    const epochs = table?.storage.get(componentId2)?.epochs;
+    if (epochs === void 0) continue;
+    epochs.added[tableRow2] = epoch;
+    publishComponentRange(epochs, tableRow2, 1, epoch);
+  }
+}
+function markComponentChanged(graph, location, entity, componentId2, epoch) {
+  const sparseSet = graph.sparseTags.get(componentId2);
+  if (sparseSet !== void 0) {
+    const denseIndex = sparseTagIndex(sparseSet, entity);
+    if (denseIndex >= 0) sparseSet.changed[denseIndex] = epoch();
+    return;
+  }
+  const archetype = graph.archetypes[location.archetypeId];
+  if (archetype === void 0) return;
+  const epochs = graph.tables[archetype.tableId]?.storage.get(componentId2)?.epochs;
+  if (epochs === void 0) return;
+  const tableRow2 = archetype.rows[location.archetypeRow] ?? -1;
+  publishComponentRange(epochs, tableRow2, 1, epoch());
+}
+function publishComponentRange(columns, start, count, epoch) {
+  if (count === 0) return;
+  if (count === 1) {
+    columns.changed[start] = epoch;
+    columns.blocks[Math.floor(start / PROJECTION_BLOCK_SIZE)] = epoch;
+    return;
+  }
+  columns.changed.fill(epoch, start, start + count);
+  columns.blocks.fill(
+    epoch,
+    Math.floor(start / PROJECTION_BLOCK_SIZE),
+    Math.ceil((start + count) / PROJECTION_BLOCK_SIZE)
+  );
+}
+var SIZE_CLASSES = Object.freeze([
+  16,
+  64,
+  256,
+  1024,
+  4096,
+  16384,
+  65536,
+  262144
+]);
+var HAS_TRANSFER2 = typeof ArrayBuffer.prototype.transfer === "function";
+function bucketIndex(byteLength) {
+  if (byteLength === 0) return -1;
+  for (let i = 0; i < SIZE_CLASSES.length; i++) {
+    const b = SIZE_CLASSES[i];
+    if (b !== void 0 && byteLength <= b) return i;
+  }
+  return SIZE_CLASSES.length;
+}
+var BufferPool = class {
+  slots = /* @__PURE__ */ new Map();
+  /**
+   * Per-bucket free-lists: `freeBuckets[i]` is a LIFO stack of slot ids
+   * whose backing buffer is parked on bucket `i`. Released slots stay on
+   * their original bucket's free-list - v1 never moves a slot between
+   * buckets on release (D-7 no trim).
+   */
+  freeBuckets = SIZE_CLASSES.map(() => []);
+  nextId = 1;
+  /**
+   * Allocate a managed buffer slot of at least `byteLength` bytes.
+   *
+   * Routes:
+   *   - invalid byteLength -> structured out-of-bounds error.
+   *   - byteLength == 0 -> ok({ id, view: zero-length Uint8Array }) (no bucket).
+   *   - byteLength <= 262144 -> ok({ id, view }), bucket = smallest >= byteLength.
+   *   - byteLength > 262144 -> a dedicated allocation; allocation failure is structured.
+   *
+   * D-5: size classes are radix-4 (16 / 64 / 256 / 1K / 4K / 16K / 64K / 256K).
+   * Free-list pop reuses the most recently released slot id at the same bucket;
+   * miss falls through to a fresh allocation.
+   */
+  alloc(byteLength) {
+    if (byteLength === 0) {
+      const id2 = this.nextId++;
+      const buffer2 = new ArrayBuffer(0);
+      const view2 = new Uint8Array(buffer2);
+      this.slots.set(id2, { sizeClassIdx: -1, buffer: buffer2, view: view2, byteLength: 0, live: true });
+      return ok({ id: id2, view: view2 });
+    }
+    if (!Number.isSafeInteger(byteLength) || byteLength < 0) {
+      return err(new ManagedBufferOutOfBoundsError(byteLength, 0));
+    }
+    const idx = bucketIndex(byteLength);
+    if (idx === SIZE_CLASSES.length) {
+      try {
+        const buffer2 = new ArrayBuffer(byteLength);
+        const view2 = new Uint8Array(buffer2);
+        const id2 = this.nextId++;
+        this.slots.set(id2, { sizeClassIdx: idx, buffer: buffer2, view: view2, byteLength, live: true });
+        return ok({ id: id2, view: view2 });
+      } catch {
+        return err(new ManagedBufferOutOfBoundsError(byteLength, 0));
+      }
+    }
+    const bucketBytes = SIZE_CLASSES[idx];
+    if (bucketBytes === void 0) {
+      return err(new ManagedBufferOutOfBoundsError(byteLength, 0));
+    }
+    const free = this.freeBuckets[idx];
+    if (free !== void 0 && free.length > 0) {
+      const id2 = free.pop();
+      const slot = this.slots.get(id2);
+      if (slot === void 0) {
+        return err(new ManagedBufferOutOfBoundsError(byteLength, 0));
+      }
+      slot.byteLength = byteLength;
+      slot.view = new Uint8Array(slot.buffer, 0, byteLength);
+      slot.live = true;
+      new Uint8Array(slot.buffer).fill(0);
+      return ok({ id: id2, view: slot.view });
+    }
+    const id = this.nextId++;
+    const buffer = new ArrayBuffer(bucketBytes);
+    const view = new Uint8Array(buffer, 0, byteLength);
+    this.slots.set(id, {
+      sizeClassIdx: idx,
+      buffer,
+      view,
+      byteLength,
+      live: true
+    });
+    return ok({ id, view });
+  }
+  /**
+   * Grow slot `id` to `newBytes`. Returns the post-grow Uint8Array view.
+   *
+   * Routes (D-6 / D-7):
+   *   - newBytes < current  -> err(managed-buffer-shrink-not-supported).
+   *   - newBytes == current -> ok(current view) (no-op, identity preserved).
+   *   - newBytes > current && same bucket -> ok(re-sliced view) (no transfer).
+   *   - newBytes > current && cross bucket -> ok(new view) backed by a fresh
+   *     bucket buffer; the prior ArrayBuffer is detached via transfer (ES2024)
+   *     or replaced via allocate-and-copy fallback. Old `view`s captured by
+   *     the caller become detached / orphaned - callers must use `pool.view(id)`
+   *     after grow to read the refreshed view (the `release` loop refreshes
+   *     automatically).
+   *   - newBytes beyond the last pooled class -> dedicated allocation.
+   */
+  grow(id, newBytes) {
+    const slot = this.slots.get(id);
+    if (slot === void 0) {
+      return err(new ManagedBufferOutOfBoundsError(newBytes, 0));
+    }
+    if (newBytes < slot.byteLength) {
+      return err(new ManagedBufferShrinkNotSupportedError(newBytes, slot.byteLength));
+    }
+    if (newBytes === slot.byteLength) {
+      return ok(slot.view);
+    }
+    if (!Number.isSafeInteger(newBytes) || newBytes < 0) {
+      return err(new ManagedBufferOutOfBoundsError(newBytes, slot.buffer.byteLength));
+    }
+    const newIdx = bucketIndex(newBytes);
+    if (newBytes <= slot.buffer.byteLength) {
+      slot.byteLength = newBytes;
+      slot.view = new Uint8Array(slot.buffer, 0, newBytes);
+      return ok(slot.view);
+    }
+    const newBucketBytes = SIZE_CLASSES[newIdx] ?? Math.max(newBytes, slot.buffer.byteLength * 2);
+    const oldByteLength = slot.byteLength;
+    let nextBuffer;
+    try {
+      if (HAS_TRANSFER2) {
+        nextBuffer = slot.buffer.transfer(newBucketBytes);
+      } else {
+        nextBuffer = new ArrayBuffer(newBucketBytes);
+        new Uint8Array(nextBuffer).set(new Uint8Array(slot.buffer, 0, oldByteLength));
+      }
+    } catch {
+      return err(new ManagedBufferOutOfBoundsError(newBytes, slot.buffer.byteLength));
+    }
+    slot.sizeClassIdx = newIdx;
+    slot.buffer = nextBuffer;
+    slot.byteLength = newBytes;
+    slot.view = new Uint8Array(nextBuffer, 0, newBytes);
+    return ok(slot.view);
+  }
+  /**
+   * Release slot `id` back to its bucket's free-list. Releasing an unknown id
+   * is a no-op - World's release loop drives this and idempotency keeps the
+   * despawn chain free of bookkeeping noise. Bucket free-lists are NEVER
+   * trimmed in v1 (D-7 no trim).
+   */
+  release(id) {
+    const slot = this.slots.get(id);
+    if (slot === void 0) return ok(void 0);
+    if (!slot.live) return ok(void 0);
+    slot.live = false;
+    if (slot.sizeClassIdx >= 0 && slot.sizeClassIdx < SIZE_CLASSES.length) {
+      const bucket = this.freeBuckets[slot.sizeClassIdx];
+      if (bucket !== void 0) bucket.push(id);
+    } else {
+      this.slots.delete(id);
+    }
+    return ok(void 0);
+  }
+  /**
+   * Return the live view for slot `id`. Used by World after `grow` to
+   * refresh the column's stored view reference. Returns a zero-length view
+   * for unknown / released ids so callers never crash on use-after-release.
+   */
+  view(id) {
+    const slot = this.slots.get(id);
+    if (slot === void 0 || !slot.live) return new Uint8Array(0);
+    return slot.view;
+  }
+  /**
+   * Return the bucket-rounded byte capacity for slot `id` --- i.e.
+   * `SIZE_CLASSES[slot.sizeClassIdx]`. Used by managed-buffer view callers
+   * (D-4 no-cache: re-queried per accessor). Returns `0` for the zero-length
+   * (`alloc(0)`) slot; returns `0` for unknown / released ids (mirrors
+   * `view(id)` use-after-release semantics).
+   */
+  byteCapacity(id) {
+    const slot = this.slots.get(id);
+    if (slot === void 0 || !slot.live) return 0;
+    if (slot.sizeClassIdx < 0) return 0;
+    return slot.buffer.byteLength;
+  }
+  /**
+   * Reset the logical byteLength of slot `id` to `newByteLength` while
+   * keeping the same bucket allocation (no transfer, no release). Only
+   * legal when `newByteLength <= bucketBytes`; the slot's bucket index
+   * does not move (D-7 v1 forbids cross-bucket shrink). Used by managed-
+   * buffer clear paths so the slot retains its `byteCapacity` while the
+   * live view becomes zero-length. Bytes past the new logical length are
+   * zero-filled defensively.
+   *
+   * Returns `err(ManagedBufferShrinkNotSupportedError)` when called on a
+   * `sizeClassIdx === -1` slot (alloc(0)) with `newByteLength > 0`, or
+   * when `newByteLength` exceeds the bucket capacity.
+   */
+  setLogicalLength(id, newByteLength) {
+    const slot = this.slots.get(id);
+    if (slot === void 0) {
+      return err(new ManagedBufferOutOfBoundsError(newByteLength, 0));
+    }
+    if (slot.sizeClassIdx < 0) {
+      if (newByteLength === 0) {
+        slot.byteLength = 0;
+        slot.view = new Uint8Array(slot.buffer);
+        return ok(slot.view);
+      }
+      return err(new ManagedBufferOutOfBoundsError(newByteLength, 0));
+    }
+    const bucketBytes = slot.buffer.byteLength;
+    if (newByteLength > bucketBytes) {
+      return err(new ManagedBufferOutOfBoundsError(newByteLength, bucketBytes));
+    }
+    if (newByteLength < slot.byteLength) {
+      new Uint8Array(slot.buffer, newByteLength, slot.byteLength - newByteLength).fill(0);
+    }
+    slot.byteLength = newByteLength;
+    slot.view = new Uint8Array(slot.buffer, 0, newByteLength);
+    return ok(slot.view);
+  }
+  /** @internal Diagnostic count of live slots. Exposed for tests + inspector. */
+  _liveCount() {
+    let n = 0;
+    for (const s of this.slots.values()) if (s.live) n += 1;
+    return n;
+  }
+};
+
+// src/component-default-fallback.ts
+function typeDefault(fieldType) {
+  if (fieldType === "bool") return false;
+  if (fieldType === "entity") return ENTITY_NULL_RAW;
+  if (fieldType === "array<entity>") return [];
+  return 0;
+}
+function fillComponentDefaults(token, raw) {
+  const schema = componentSchema(token);
+  const layer2 = componentDefinition(token).defaults;
+  const out = /* @__PURE__ */ Object.create(null);
+  const rawObj = raw ?? void 0;
+  for (const fieldName of Object.keys(schema)) {
+    const fieldType = schema[fieldName];
+    if (fieldType === void 0) continue;
+    if (rawObj !== void 0 && fieldName in rawObj) {
+      out[fieldName] = rawObj[fieldName];
+      continue;
+    }
+    if (layer2 !== void 0 && fieldName in layer2) {
+      out[fieldName] = layer2[fieldName];
+      continue;
+    }
+    out[fieldName] = typeDefault(fieldType);
+  }
+  return out;
 }
-function getRemoveEdge(graph, src, componentId2) {
-  const cached = src.removeEdges.get(componentId2);
-  if (cached !== void 0) {
-    const target2 = graph.archetypes[cached];
-    if (target2) {
-      return target2;
+function validateComponentDataKeys(token, raw) {
+  if (raw === void 0) return null;
+  const schema = componentSchema(token);
+  const rawObj = raw;
+  for (const fieldName of Object.keys(rawObj)) {
+    if (!(fieldName in schema)) {
+      return new SpawnDataUnknownFieldError(token.name, fieldName, Object.keys(schema));
     }
   }
-  const newIds = src.components.map((c) => componentId(c)).filter((id) => id !== componentId2);
-  const newComponents = src.components.filter((c) => componentId(c) !== componentId2);
-  const target = getOrCreateArchetype(graph, newIds, newComponents);
-  src.removeEdges.set(componentId2, target.id);
-  return target;
+  return null;
 }
 
-// src/storage/change-detection.ts
-var INITIAL_SPARSE_CAPACITY = 64;
-function createComponentEpochColumns(capacity) {
-  return { added: new Float64Array(capacity), changed: new Float64Array(capacity) };
-}
-function growComponentEpochColumns(columns, capacity) {
-  const added = new Float64Array(capacity);
-  const changed = new Float64Array(capacity);
-  added.set(columns.added);
-  changed.set(columns.changed);
-  return { added, changed };
-}
-function copyComponentEpoch(source, sourceRow, target, targetRow) {
-  target.added[targetRow] = source.added[sourceRow] ?? 0;
-  target.changed[targetRow] = source.changed[sourceRow] ?? 0;
-}
-function createSparseTagSet(component) {
-  const sparse = new Int32Array(INITIAL_SPARSE_CAPACITY);
-  sparse.fill(-1);
-  return {
-    component,
-    sparse,
-    dense: new Uint32Array(INITIAL_SPARSE_CAPACITY),
-    added: new Float64Array(INITIAL_SPARSE_CAPACITY),
-    changed: new Float64Array(INITIAL_SPARSE_CAPACITY),
-    size: 0
-  };
-}
-function sparseTagIndex(set, entity) {
-  const denseIndex = set.sparse[entityIndex(entity)] ?? -1;
-  return denseIndex >= 0 && set.dense[denseIndex] === entity ? denseIndex : -1;
-}
-function insertSparseTag(set, entity, epoch) {
-  const present = sparseTagIndex(set, entity);
-  if (present >= 0) {
-    set.changed[present] = epoch;
-    return present;
-  }
-  growSparseSlots(set, entityIndex(entity) + 1);
-  if (set.size === set.dense.length) growSparseDense(set, set.size + 1);
-  const denseIndex = set.size;
-  set.dense[denseIndex] = entity;
-  set.added[denseIndex] = epoch;
-  set.changed[denseIndex] = epoch;
-  set.sparse[entityIndex(entity)] = denseIndex;
-  set.size += 1;
-  return denseIndex;
+// src/component-value-validate.ts
+function isNumericHandle(v) {
+  return typeof v === "number";
 }
-function removeSparseTag(set, entity) {
-  const denseIndex = sparseTagIndex(set, entity);
-  if (denseIndex < 0) return false;
-  const lastIndex = set.size - 1;
-  set.sparse[entityIndex(entity)] = -1;
-  if (denseIndex !== lastIndex) {
-    const movedEntity = set.dense[lastIndex];
-    set.dense[denseIndex] = movedEntity;
-    set.added[denseIndex] = set.added[lastIndex] ?? 0;
-    set.changed[denseIndex] = set.changed[lastIndex] ?? 0;
-    set.sparse[entityIndex(movedEntity)] = denseIndex;
-  }
-  set.size = lastIndex;
-  return true;
+function isSharedScalarType(fieldType) {
+  return fieldType.startsWith("shared<") && fieldType.endsWith(">");
 }
-function growSparseSlots(set, targetCapacity) {
-  if (targetCapacity <= set.sparse.length) return;
-  let capacity = set.sparse.length;
-  while (capacity < targetCapacity) capacity *= 2;
-  const sparse = new Int32Array(capacity);
-  sparse.fill(-1);
-  sparse.set(set.sparse);
-  set.sparse = sparse;
+function isSharedArrayType(fieldType) {
+  if (!fieldType.startsWith("array<") || !fieldType.endsWith(">")) return false;
+  const inner = fieldType.slice(6, -1);
+  const head = inner.indexOf(",") === -1 ? inner : inner.slice(0, inner.indexOf(",")).trim();
+  return head.startsWith("shared<") && head.endsWith(">");
 }
-function growSparseDense(set, targetCapacity) {
-  let capacity = set.dense.length;
-  while (capacity < targetCapacity) capacity *= 2;
-  const dense = new Uint32Array(capacity);
-  dense.set(set.dense);
-  set.dense = dense;
-  const added = new Float64Array(capacity);
-  added.set(set.added);
-  set.added = added;
-  const changed = new Float64Array(capacity);
-  changed.set(set.changed);
-  set.changed = changed;
+function isArrayPayload(value) {
+  if (Array.isArray(value)) return true;
+  return ArrayBuffer.isView(value) && typeof value.length === "number";
 }
-function readComponentChange(graph, location, entity, componentId2) {
-  const sparseSet = graph.sparseTags.get(componentId2);
-  if (sparseSet !== void 0) {
-    const denseIndex = sparseTagIndex(sparseSet, entity);
-    if (denseIndex < 0) return void 0;
-    return {
-      added: sparseSet.added[denseIndex] ?? 0,
-      changed: sparseSet.changed[denseIndex] ?? 0
-    };
+function validateManagedArrayValues(token, raw) {
+  if (raw === void 0) return null;
+  const fields = componentDefinition(token).fields;
+  const rawObj = raw;
+  for (const fieldName of Object.keys(rawObj)) {
+    const reflection = fields[fieldName];
+    if (reflection?.arrayMeta === void 0) continue;
+    const value = rawObj[fieldName];
+    if (value === 0) continue;
+    if (value === void 0 || value === null || isArrayPayload(value)) continue;
+    return new ManagedArrayInvalidValueError(token.name, fieldName, reflection.type, value);
   }
-  const archetype = graph.archetypes[location.archetypeId];
-  if (archetype === void 0) return void 0;
-  const epochs = graph.tables[archetype.tableId]?.storage.get(componentId2)?.epochs;
-  if (epochs === void 0) return void 0;
-  const tableRow2 = archetype.rows[location.archetypeRow] ?? -1;
-  return {
-    added: epochs.added[tableRow2] ?? 0,
-    changed: epochs.changed[tableRow2] ?? 0
-  };
+  return null;
 }
-function markComponentsAdded(graph, location, entity, componentIds, epoch) {
-  const archetype = graph.archetypes[location.archetypeId];
-  const table = archetype === void 0 ? void 0 : graph.tables[archetype.tableId];
-  const tableRow2 = archetype?.rows[location.archetypeRow] ?? -1;
-  for (const componentId2 of componentIds) {
-    const component = archetype?.components.find(
-      (candidate) => componentId(candidate) === componentId2
-    );
-    if (component?.storage === "sparse") {
-      insertSparseTag(getOrCreateSparseTagSet(graph, component), entity, epoch);
-      continue;
+function validateSharedFieldValues(token, raw) {
+  if (raw === void 0) return null;
+  const schema = componentSchema(token);
+  const rawObj = raw;
+  for (const fieldName of Object.keys(rawObj)) {
+    const fieldType = schema[fieldName];
+    if (fieldType === void 0) continue;
+    const value = rawObj[fieldName];
+    if (value === void 0 || value === null) continue;
+    if (isSharedScalarType(fieldType)) {
+      if (!isNumericHandle(value)) {
+        return new SharedFieldInvalidValueError(token.name, fieldName, fieldType, value);
+      }
+    } else if (isSharedArrayType(fieldType)) {
+      if (!Array.isArray(value)) continue;
+      for (let i = 0; i < value.length; i++) {
+        const el = value[i];
+        if (el === void 0 || el === null) continue;
+        if (!isNumericHandle(el)) {
+          return new SharedFieldInvalidValueError(token.name, fieldName, fieldType, el, i);
+        }
+      }
     }
-    const epochs = table?.storage.get(componentId2)?.epochs;
-    if (epochs === void 0) continue;
-    epochs.added[tableRow2] = epoch;
-    epochs.changed[tableRow2] = epoch;
-  }
-}
-function markComponentChanged(graph, location, entity, componentId2, epoch) {
-  const sparseSet = graph.sparseTags.get(componentId2);
-  if (sparseSet !== void 0) {
-    const denseIndex = sparseTagIndex(sparseSet, entity);
-    if (denseIndex >= 0) sparseSet.changed[denseIndex] = epoch();
-    return;
   }
-  const archetype = graph.archetypes[location.archetypeId];
-  if (archetype === void 0) return;
-  const epochs = graph.tables[archetype.tableId]?.storage.get(componentId2)?.epochs;
-  if (epochs === void 0) return;
-  const tableRow2 = archetype.rows[location.archetypeRow] ?? -1;
-  epochs.changed[tableRow2] = epoch();
+  return null;
 }
+
+// src/internal.ts
+var DERIVED_WRITER = /* @__PURE__ */ Symbol.for(
+  "forgeax.ecs.query.derivedWriter"
+);
 function createDerivedRangeWriter(world, component, source) {
   let boundEpoch = -1;
   let bindingTables = [];
@@ -2686,14 +2734,11 @@ var QueryRowFacade = class _QueryRowFacade {
     return new _QueryRowFacade(this.world).bind(this.entity, this.archetype);
   }
   has(component) {
-    return this.archetype?.components.some(
-      (candidate) => componentId(candidate) === componentId(component)
-    ) === true;
+    const id = componentId(component);
+    return this.archetype?.components.some((candidate) => componentId(candidate) === id) === true;
   }
   get(component) {
-    if (!this.archetype?.components.some(
-      (candidate) => componentId(candidate) === componentId(component)
-    )) {
+    if (!this.has(component)) {
       return void 0;
     }
     const result = this.world[worldInternal].getQueryRow(this.entity, component);
@@ -2805,8 +2850,9 @@ var ExecutableQuery = class {
     const structureEpoch = this.world[worldInternal].getStructureEpoch();
     const upperBound = this.world[worldInternal].getMutationEpoch();
     const row = new QueryRowFacade(this.world);
-    let archetypeIndex = 0;
-    let tableIndex = 0;
+    const unchanged = this.hasUnchangedInput();
+    let archetypeIndex = unchanged ? this.matchedArchetypes.length : 0;
+    let tableIndex = unchanged ? this.matchedTables.length : 0;
     let rowIndex = 0;
     let finished = false;
     const close = (commit) => {
@@ -2874,7 +2920,7 @@ var ExecutableQuery = class {
   at(entity) {
     const archetype = this.world[worldInternal].getEntityArchetype(entity);
     if (archetype === void 0 || !this.archetypeMatches(archetype)) return void 0;
-    return new QueryRowFacade(this.world).bind(entity, archetype).snapshot();
+    return new QueryRowFacade(this.world).bind(entity, archetype);
   }
   spans() {
     const reason = this.spanUnavailableReason();
@@ -2886,7 +2932,8 @@ var ExecutableQuery = class {
         query.refreshMatches();
         const structureEpoch = query.world[worldInternal].getStructureEpoch();
         const upperBound = query.world[worldInternal].getMutationEpoch();
-        let tableIndex = 0;
+        const filterIds = [...query.compiled.changedIds, ...query.compiled.addedIds];
+        let tableIndex = query.hasUnchangedInput() ? query.matchedTables.length : 0;
         let rowIndex = 0;
         let finished = false;
         const close = (commit) => {
@@ -2921,7 +2968,11 @@ var ExecutableQuery = class {
                 };
               }
               while (rowIndex < table.size && !query.denseChangeMatches(table, rowIndex, upperBound)) {
-                rowIndex += 1;
+                const block = Math.floor(rowIndex / PROJECTION_BLOCK_SIZE);
+                const unchanged = filterIds.some(
+                  (id) => (table.storage.get(id)?.epochs.blocks[block] ?? 0) <= query.lastObservedEpoch
+                );
+                rowIndex = unchanged ? (block + 1) * PROJECTION_BLOCK_SIZE : rowIndex + 1;
               }
               if (rowIndex >= table.size) {
                 tableIndex += 1;
@@ -3009,6 +3060,10 @@ var ExecutableQuery = class {
       }
     };
   }
+  hasUnchangedInput() {
+    const epochs = this.world[worldInternal].getComponentMutationEpochs();
+    return this.compiled.changedIds.some((id) => (epochs[id] ?? 0) <= this.lastObservedEpoch);
+  }
   beginIteration() {
     if (this.active) throw new QueryIterationActiveError();
     this.active = true;
@@ -3925,7 +3980,6 @@ function runSchedule(schedule, world, selectedNames, commandsBySystem = /* @__PU
     if (!completed || finalDrain) abortOutstandingCommands(commandsBySystem);
   }
 }
-var SHARED_REF_RELEASE_EVIDENCE_CAPACITY = 4096;
 var SharedRefStore = class {
   payloads = /* @__PURE__ */ new Map();
   refcounts = /* @__PURE__ */ new Map();
@@ -3933,10 +3987,7 @@ var SharedRefStore = class {
   internedByTarget = /* @__PURE__ */ new Map();
   internedKeys = /* @__PURE__ */ new Map();
   nextSlot = BUILTIN_BASE;
-  mutationEpoch = 0;
   /** Latest published mutation epoch per live handle; not an event journal. */
-  mutationEpochs = /* @__PURE__ */ new Map();
-  releaseJournal = [];
   /**
    * Generation table indexed by slot (D-6). Each entry tracks the current
    * generation for the slot — written to during alloc (welded into the
@@ -4032,32 +4083,6 @@ var SharedRefStore = class {
    * projections of shared payload data compare the monotonic epoch and
    * explicitly refresh instead of rescanning every payload each frame.
    */
-  markChanged(handle) {
-    const resolved = this.resolve(handle);
-    if (!resolved.ok) return resolved;
-    if (this.mutationEpoch >= Number.MAX_SAFE_INTEGER) {
-      throw new RangeError("SharedRefStore mutation epoch exhausted");
-    }
-    this.mutationEpoch += 1;
-    this.mutationEpochs.set(unwrapHandle(handle), this.mutationEpoch);
-    return ok(void 0);
-  }
-  /** Current upper bound for explicitly published payload mutations. */
-  getMutationEpoch() {
-    return this.mutationEpoch;
-  }
-  /** Read each live handle whose latest published mutation is after `cursor`. */
-  readChangesSince(cursor) {
-    const records = [];
-    for (const [handle, epoch] of this.mutationEpochs) {
-      if (epoch > cursor) records.push({ epoch, handle });
-    }
-    records.sort((left, right) => left.epoch - right.epoch || left.handle - right.handle);
-    return {
-      cursor: this.mutationEpoch,
-      records
-    };
-  }
   /**
    * Increment the refcount of a live shared handle. Returns
    * `err(shared-ref-released)` when the handle is not live - retain MUST
@@ -4121,7 +4146,6 @@ var SharedRefStore = class {
     }
     this.refcounts.delete(raw);
     this.payloads.delete(raw);
-    this.mutationEpochs.delete(raw);
     const generation = storeGen + 1;
     this._generations[slot] = generation;
     if (!isRetiredSlot(generation)) {
@@ -4133,23 +4157,8 @@ var SharedRefStore = class {
       generation,
       evidence: "released"
     });
-    this.releaseJournal.push(
-      Object.freeze({
-        handle: raw,
-        refcount: 0,
-        generation,
-        evidence: "released"
-      })
-    );
-    if (this.releaseJournal.length > SHARED_REF_RELEASE_EVIDENCE_CAPACITY) {
-      this.releaseJournal.shift();
-    }
     return ok(evidence);
   }
-  /** Read bounded release metadata; payload ownership remains with the caller. */
-  readReleaseEvidence() {
-    return this.releaseJournal;
-  }
   /**
    * Return the current refcount for `handle`. Returns 0 for a released
    * (or never-allocated) slot. Primarily a debug + tests entry point;
@@ -4165,47 +4174,6 @@ var SharedRefStore = class {
     return this.payloads.size;
   }
 };
-
-// src/storage/structural-evidence.ts
-var StructuralEvidenceRing = class {
-  constructor(capacity = 1024) {
-    this.capacity = capacity;
-    if (!Number.isSafeInteger(capacity) || capacity <= 0) {
-      throw new RangeError("StructuralEvidenceRing capacity must be a positive safe integer");
-    }
-    this.events = new Array(capacity);
-  }
-  capacity;
-  events;
-  nextSequence = 1;
-  get cursor() {
-    return this.nextSequence - 1;
-  }
-  append(input) {
-    const sequence = this.nextSequence;
-    this.nextSequence += 1;
-    this.events[(sequence - 1) % this.capacity] = { ...input, sequence };
-    return sequence;
-  }
-  readAfter(cursor) {
-    const latest = this.cursor;
-    if (!Number.isSafeInteger(cursor) || cursor < 0 || cursor > latest) {
-      throw new RangeError(`StructuralEvidenceRing cursor ${cursor} is outside 0..${latest}`);
-    }
-    const oldestAvailable = Math.max(1, latest - this.capacity + 1);
-    if (cursor < oldestAvailable - 1)
-      return { status: "overflow", cursor: latest, oldestAvailable };
-    const events = [];
-    for (let sequence = cursor + 1; sequence <= latest; sequence += 1) {
-      const event = this.events[(sequence - 1) % this.capacity];
-      if (event === void 0 || event.sequence !== sequence) {
-        return { status: "overflow", cursor: latest, oldestAvailable };
-      }
-      events.push(event);
-    }
-    return { status: "ok", cursor: latest, events };
-  }
-};
 var UniqueRefStore = class {
   payloads = /* @__PURE__ */ new Map();
   freeSlots = [];
@@ -5057,7 +5025,6 @@ var World = class {
   /** Per-World shared-ref store; public read-only for direct handle operations. */
   sharedRefs = new SharedRefStore();
   componentMutationEpochs = [];
-  structuralEvidence = new StructuralEvidenceRing();
   /** One packed reverse index per relationship source component. */
   relationshipIndexes = /* @__PURE__ */ new Map();
   mutationEpoch = 0;
@@ -5112,7 +5079,6 @@ var World = class {
       getSchedules: () => this.schedules,
       getSharedRefs: () => this.sharedRefs,
       getStructureEpoch: this.getStructureEpoch.bind(this),
-      getStructuralEvidence: () => this.structuralEvidence,
       lookupAlive: this.lookupAlive.bind(this),
       markComponentChanged: this.internalmarkComponentChanged.bind(this),
       markComponentRangeChanged: this.internalmarkComponentRangeChanged.bind(this),
@@ -5177,9 +5143,6 @@ var World = class {
     }
     return worldScheduleUsesComponent(this, component);
   }
-  recordStructuralEvidence(evidence) {
-    this.structuralEvidence.append(evidence);
-  }
   /** Resolve current logical identity for a packed entity handle. */
   internalgetEntityArchetype(entity) {
     const record = this.records[entityIndex(entity)];
@@ -5208,7 +5171,7 @@ var World = class {
     if (epochs === void 0) {
       throw new Error(`Derived component ${componentId2} is not in the table.`);
     }
-    epochs.changed.fill(epoch, rowStart, rowStart + rowCount);
+    publishComponentRange(epochs, rowStart, rowCount, epoch);
     this.componentMutationEpochs[componentId2] = epoch;
   }
   /** Record one successful structural mutation. */
@@ -5247,7 +5210,7 @@ var World = class {
     const epochs = table.storage.get(componentId2)?.epochs;
     if (epochs === void 0 || rowCount === 0) return;
     const epoch = this.internalnextMutationEpoch();
-    epochs.changed.fill(epoch, rowStart, rowStart + rowCount);
+    publishComponentRange(epochs, rowStart, rowCount, epoch);
     this.componentMutationEpochs[componentId2] = epoch;
   }
   /** Query facade write after the facade has already marked evidence. */
@@ -5871,11 +5834,6 @@ var World = class {
     if (mirrorAdded) {
       this.internalmarkComponentsAdded(target, [mirrorLocalId]);
       this.advanceStructureEpoch();
-      this.recordStructuralEvidence({
-        kind: "component-added",
-        entity: target,
-        componentId: mirrorLocalId
-      });
     }
     return ok(void 0);
   }
@@ -6076,12 +6034,7 @@ var World = class {
       data: value
     });
     if (!valuePreflight.ok) return valuePreflight;
-    const currentValue = this.readRow(arch, component, row);
-    const mergedValue = {
-      ...currentValue,
-      ...value
-    };
-    const enumError = validateEnumFieldValues(component, mergedValue, entity);
+    const enumError = validateEnumFieldValues(component, value, entity);
     if (enumError !== null) return err(enumError);
     if (component.storage === "sparse") {
       if (markChanged) this.markComponentChanged(entity, component);
@@ -6456,11 +6409,6 @@ var World = class {
     if (!internal) {
       this.internalmarkComponentsAdded(entity, [componentId(componentData.component)]);
       this.advanceStructureEpoch();
-      this.recordStructuralEvidence({
-        kind: "component-added",
-        entity,
-        componentId: localId
-      });
     }
     return ok(void 0);
   }
@@ -6542,12 +6490,8 @@ var World = class {
       this.migrateEntity(rec, srcArch, targetArch);
     }
     if (!internal) {
+      this.internalnextMutationEpoch();
       this.advanceStructureEpoch();
-      this.recordStructuralEvidence({
-        kind: "component-removed",
-        entity,
-        componentId: localId
-      });
     }
     return ok(void 0);
   }
@@ -6597,7 +6541,7 @@ var World = class {
       record.archetypeId = arch.id;
       storageTouched = true;
       const table = this.table(arch);
-      const tableRow2 = appendTableRow(table, entity);
+      const tableRow2 = appendTableRow(table, entity, this.mutationEpoch + 1);
       const archetypeRow = appendArchetypeRow(arch, tableRow2);
       record.archetypeRow = archetypeRow;
       for (const cd of componentDatas) {
@@ -6623,7 +6567,6 @@ var World = class {
         ...componentDatas.map((cd) => componentId(cd.component))
       ]);
       this.advanceStructureEpoch();
-      this.recordStructuralEvidence({ kind: "spawn", entity });
       return ok(void 0);
     } catch (error) {
       if (storageTouched) this.poisonAfterEntityMutation("World.materializeEntity", error);
@@ -7003,6 +6946,18 @@ var World = class {
     const elementBytes = meta.byteSize;
     const isVariable = arrayMeta.length === void 0;
     const fixedLength = arrayMeta.length ?? 0;
+    if (!isVariable && metaKey !== "shared" && meta.viewCtor !== void 0 && col.view instanceof meta.viewCtor && (raw == null || Array.isArray(raw) || raw instanceof meta.viewCtor)) {
+      const start = row * col.arity;
+      const count = raw == null ? 0 : Math.min(raw.length, col.arity);
+      if (Array.isArray(raw)) {
+        for (let i = 0; i < count; i++)
+          col.view[start + i] = typeof raw[i] === "number" ? raw[i] : 0;
+      } else if (raw != null) {
+        col.view.set(raw.length <= col.arity ? raw : raw.subarray(0, count), start);
+      }
+      col.view.fill(0, start + count, start + col.arity);
+      return;
+    }
     let payloadCount = 0;
     let payloadBytes = null;
     if (raw !== null && raw !== void 0) {
@@ -7141,7 +7096,7 @@ var World = class {
     const srcTable = this.table(srcArch);
     const targetTable = this.table(targetArch);
     const entity = srcTable.storage.get(componentId(Entity))?.fields.get("self")?.view[oldTableRow] ?? 0;
-    const newTableRow = appendTableRow(targetTable, entity);
+    const newTableRow = appendTableRow(targetTable, entity, this.mutationEpoch + 1);
     const newArchetypeRow = appendArchetypeRow(targetArch, newTableRow);
     for (const [compId, srcComponentStorage] of srcTable.storage) {
       const srcFieldCols = srcComponentStorage.fields;
@@ -7178,7 +7133,7 @@ var World = class {
         movedRecord.archetypeRow = archetypeSwap.newRow;
       }
     }
-    const tableSwap = removeTableRow(srcTable, oldTableRow);
+    const tableSwap = removeTableRow(srcTable, oldTableRow, this.mutationEpoch + 1);
     if (tableSwap !== null) {
       const movedRecord = this.records[entityIndex(tableSwap.movedEntity)];
       if (movedRecord?.generation === entityGeneration(tableSwap.movedEntity)) {
@@ -7208,6 +7163,7 @@ var World = class {
     }
     record.archetypeId = targetArch.id;
     record.archetypeRow = appendArchetypeRow(targetArch, tableRow2);
+    markTableMembership(table, tableRow2, this.mutationEpoch + 1);
   }
   /**
    * Retire one live entity and any linked-spawn descendants. The complete
@@ -7254,7 +7210,7 @@ var World = class {
             movedRecord.archetypeRow = archetypeSwap.newRow;
           }
         }
-        const tableSwap = removeTableRow(table, tableRow2);
+        const tableSwap = removeTableRow(table, tableRow2, this.mutationEpoch + 1);
         if (tableSwap !== null) {
           const movedRecord = this.records[entityIndex(tableSwap.movedEntity)];
           if (movedRecord?.generation === entityGeneration(tableSwap.movedEntity)) {
@@ -7265,7 +7221,6 @@ var World = class {
           }
         }
       }
-      this.recordStructuralEvidence({ kind: "despawn", entity });
       record.archetypeId = -1;
       record.archetypeRow = -1;
       record.generation += 1;
@@ -7274,6 +7229,7 @@ var World = class {
         const childResult = this.despawnEntity(child, true);
         if (!childResult.ok) return childResult;
       }
+      this.internalnextMutationEpoch();
       this.advanceStructureEpoch();
       return ok(void 0);
     } catch (error) {