@forgeax/engine-ecs 0.1.32 → 0.1.34

package/src/__tests__/world-health.contract.test.ts

@@ -28,7 +28,6 @@ describe('World execution health', () => {
     const injected = new ComponentNotPresentError(target as number, 'InjectedRelationshipFailure');
     const mutationEpoch = world[worldInternal].getMutationEpoch();
     const structureEpoch = world.getStructureEpoch();
-    const evidenceCursor = world[worldInternal].getStructuralEvidence().cursor;
     const onInsert = vi.spyOn(
       world as unknown as {
         relationshipOnInsert: (...args: never[]) => unknown;
@@ -45,7 +44,6 @@ describe('World execution health', () => {
     expect(world.execution.fault?.partialWrite).toBe(true);
     expect(world[worldInternal].getMutationEpoch()).toBe(mutationEpoch);
     expect(world.getStructureEpoch()).toBe(structureEpoch);
-    expect(world[worldInternal].getStructuralEvidence().cursor).toBe(evidenceCursor);
     const rejected = world.spawn();
     expect(rejected.ok).toBe(false);
     if (!rejected.ok) expect(rejected.error.code).toBe('world-poisoned');
@@ -89,7 +87,6 @@ describe('World execution health', () => {
     });
     const pending = buffer.spawn({ component: WorldHealthChildOf, data: { parent: target } });
     const mutationEpoch = world[worldInternal].getMutationEpoch();
-    const evidenceCursor = world[worldInternal].getStructuralEvidence().cursor;
 
     expect(() => flushCommands(buffer, world)).toThrow();
     expect(buffer.status).toBe('aborted');
@@ -97,7 +94,6 @@ describe('World execution health', () => {
     expect(world.execution.fault?.partialWrite).toBe(true);
     expect(world.hasComponent(pending, WorldHealthChildOf)).toBe(true);
     expect(world[worldInternal].getMutationEpoch()).toBe(mutationEpoch);
-    expect(world[worldInternal].getStructuralEvidence().cursor).toBe(evidenceCursor);
     const rejected = world.spawn();
     expect(rejected.ok).toBe(false);
     if (!rejected.ok) expect(rejected.error.code).toBe('world-poisoned');
@@ -115,7 +111,6 @@ describe('World execution health', () => {
       .unwrap();
     const mutationEpoch = world[worldInternal].getMutationEpoch();
     const structureEpoch = world.getStructureEpoch();
-    const evidenceCursor = world[worldInternal].getStructuralEvidence().cursor;
 
     world.addComponent(child, { component: WorldHealthChildOf, data: { parent } }).unwrap();
 
@@ -131,24 +126,6 @@ describe('World execution health', () => {
     expect(targetChange?.added).toBeGreaterThan(0);
     expect(world[worldInternal].getMutationEpoch()).toBeGreaterThan(mutationEpoch);
     expect(world.getStructureEpoch()).toBeGreaterThan(structureEpoch);
-    const evidence = world[worldInternal].getStructuralEvidence().readAfter(evidenceCursor);
-    expect(evidence.status).toBe('ok');
-    if (evidence.status === 'ok') {
-      expect(evidence.events).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            kind: 'component-added',
-            entity: parent,
-            componentId: componentId(WorldHealthChildren),
-          }),
-          expect.objectContaining({
-            kind: 'component-added',
-            entity: child,
-            componentId: componentId(WorldHealthChildOf),
-          }),
-        ]),
-      );
-    }
   });
 
   it('publishes target mirror evidence through addChild', () => {

package/src/index.ts

@@ -244,7 +244,7 @@ export type {
  * // the SharedRefStore publishes release evidence at rc=0.
  * ```
  */
-export type { SharedRefReleaseEvidence, SharedRefReleaseRecord } from './shared-ref-store.js';
+export type { SharedRefReleaseEvidence } from './shared-ref-store.js';
 
 /**
  * ECS-managed handle store (M1). Owns the lifecycle of every

package/src/projection/index.ts

@@ -2,8 +2,6 @@ import type { Result } from '@forgeax/engine-types';
 import type { Component } from '../component';
 import { componentId } from '../component';
 import type { EntityHandle } from '../entity-handle';
-import type { SharedRefMutationRead } from '../shared-ref-store';
-import type { StructuralEvidenceRead } from '../storage/structural-evidence';
 import type { EcsError, World } from '../world';
 import { worldInternal } from '../world-internal';
 
@@ -24,11 +22,6 @@ export {
   StaleEntityError,
 } from '../errors';
 
-/** Read producer-owned typed structural facts without inferring from a World scan. */
-export function readStructuralEvidence(world: World, cursor: number): StructuralEvidenceRead {
-  return world[worldInternal].getStructuralEvidence().readAfter(cursor) as StructuralEvidenceRead;
-}
-
 export interface RenderProjectionComponentRequest {
   readonly component: Component;
   readonly fields: readonly string[];
@@ -45,24 +38,12 @@ export interface RenderProjectionSpan {
 
 export interface RenderProjectionSpans {
   readonly generation: number;
-  readonly sharedRefEpoch: number;
   readonly spans: readonly RenderProjectionSpan[];
 }
 
-export interface RenderChangeBatchOk {
-  readonly status: 'ok';
-  readonly version: RenderReadVersion;
-  readonly world: RenderWorldChanges;
-  readonly sharedRefs: SharedRefMutationRead;
-}
-
-export interface RenderChangeBatchRebuild {
-  readonly status: 'rebuild';
+export interface RenderChangeBatch {
   readonly version: RenderReadVersion;
-  readonly resync: true;
-  readonly reason: 'structure-changed';
   readonly world: RenderWorldChanges;
-  readonly sharedRefs: SharedRefMutationRead;
 }
 
 export interface RenderWorldChanges {
@@ -71,8 +52,6 @@ export interface RenderWorldChanges {
   readonly changedComponentIds: readonly number[];
 }
 
-export type RenderChangeBatch = RenderChangeBatchOk | RenderChangeBatchRebuild;
-
 export interface RenderReadLease {
   readonly worldIdentity: string;
   readonly generation: number;
@@ -101,7 +80,6 @@ export function readRenderArrayView(
 export interface RenderReadVersion {
   readonly mutationEpoch: number;
   readonly structureEpoch: number;
-  readonly sharedRefEpoch: number;
 }
 
 function readProjectionSpans(
@@ -133,7 +111,6 @@ function readProjectionSpans(
   }
   return {
     generation,
-    sharedRefEpoch: world[worldInternal].getSharedRefs().getMutationEpoch(),
     spans: Object.freeze(spans),
   };
 }
@@ -141,7 +118,6 @@ function readProjectionSpans(
 /** Create the render-owned lease from the ECS projection boundary. */
 export function createRenderReadLease(world: World, token: object = {}): RenderReadLease {
   void token;
-  const sharedRefs = world[worldInternal].getSharedRefs();
   let disposed = false;
 
   const assertLive = (): void => {
@@ -152,7 +128,6 @@ export function createRenderReadLease(world: World, token: object = {}): RenderR
     return {
       mutationEpoch: world[worldInternal].getMutationEpoch(),
       structureEpoch: world[worldInternal].getStructureEpoch(),
-      sharedRefEpoch: sharedRefs.getMutationEpoch(),
     };
   };
 
@@ -181,20 +156,8 @@ export function createRenderReadLease(world: World, token: object = {}): RenderR
         toEpoch,
         changedComponentIds,
       };
-      const sharedRead = sharedRefs.readChangesSince(start.sharedRefEpoch);
       const version = captureVersion();
-      const structureChanged = start.structureEpoch !== world[worldInternal].getStructureEpoch();
-      if (structureChanged) {
-        return {
-          status: 'rebuild',
-          version,
-          resync: true,
-          reason: 'structure-changed',
-          world: worldRead,
-          sharedRefs: sharedRead,
-        };
-      }
-      return { status: 'ok', version, world: worldRead, sharedRefs: sharedRead };
+      return { version, world: worldRead };
     },
     querySpans(request: RenderProjectionRequest): RenderProjectionSpans {
       assertLive();
@@ -235,3 +198,10 @@ export function routeWorldError(
 ): void {
   world[worldInternal].routeError(error, context);
 }
+
+export {
+  createStateProjection,
+  type StateProjection,
+  type StateProjectionBatch,
+  StateProjectionExpiredError,
+} from './state-projection';

package/src/projection/state-projection.ts

@@ -0,0 +1,250 @@
+import type { Component } from '../component';
+import { componentId } from '../component';
+import { Entity } from '../entity';
+import { type EntityHandle, encodeEntity, entityIndex } from '../entity-handle';
+import { WorldPoisonedError } from '../errors';
+import { PROJECTION_BLOCK_SIZE } from '../storage/change-detection';
+import type { Table } from '../storage/table';
+import type { World } from '../world';
+import { worldInternal } from '../world-internal';
+
+interface BlockBaseline {
+  readonly ids: Uint32Array;
+  readonly membership: number;
+}
+
+export class StateProjectionExpiredError extends Error {
+  readonly code = 'state-projection-expired' as const;
+  readonly expected = 'an unmodified source and the latest valid projection candidate';
+  readonly hint = 'Read and apply the current state again before accepting the candidate.';
+
+  constructor() {
+    super('State projection candidate expired; read and apply the current state again.');
+    this.name = 'StateProjectionExpiredError';
+  }
+}
+
+export interface StateProjectionBatch {
+  /** Source indices, deduplicated across migration and generation replacement. */
+  readonly indices: readonly number[];
+  readonly epoch: number;
+  readonly scannedRows: number;
+  readonly checkedBlocks: number;
+  readonly membershipChanged: boolean;
+  readonly changedComponents: readonly Component[];
+  /** Commit only after the owning consumer has successfully applied its candidate. */
+  validate(): void;
+  accept(): void;
+}
+
+export interface StateProjection {
+  /** Whether the accepted source still matches the live World, without creating a candidate. */
+  isCurrent(): boolean;
+  read(): StateProjectionBatch;
+  /** Resolve the final live generation directly through the World record. */
+  entity(index: number): EntityHandle | undefined;
+  changed(entity: EntityHandle, component: Component): boolean;
+  invalidate(): void;
+}
+
+/**
+ * Current-state candidate discovery. Blocks remember accepted identities, never
+ * structural operations. Reads are synchronous and accepting a candidate does
+ * not consume evidence belonging to another projection.
+ */
+export function createStateProjection(
+  world: World,
+  components: readonly Component[],
+  candidates: readonly Component[] = components,
+): StateProjection {
+  const owner = world[worldInternal];
+  const graph = owner.getGraph();
+  const ids = components.map(componentId);
+  const candidateIds = candidates.map(componentId);
+  const sparseCandidates = candidates.some((component) => component.storage === 'sparse');
+  const baseline = new Map<Table, Map<number, BlockBaseline>>();
+  let acceptedEpoch = -1;
+  let acceptedStructure = -1;
+  let invalid = true;
+  let readToken = 0;
+  let stamp = new Uint32Array(64);
+  let serial = 0;
+  const work: number[] = [];
+
+  function enqueue(index: number): void {
+    if (index >= stamp.length) {
+      let size = stamp.length;
+      while (size <= index) size *= 2;
+      const next = new Uint32Array(size);
+      next.set(stamp);
+      stamp = next;
+    }
+    if (stamp[index] === serial) return;
+    stamp[index] = serial;
+    work.push(index);
+  }
+
+  return {
+    isCurrent() {
+      return (
+        world.execution.health !== 'poisoned' &&
+        !invalid &&
+        acceptedEpoch === owner.getMutationEpoch() &&
+        acceptedStructure === owner.getStructureEpoch()
+      );
+    },
+    entity(index) {
+      const record = owner.getRecords()[index];
+      if (record === undefined || record.archetypeId < 0) return undefined;
+      return encodeEntity(index, record.generation);
+    },
+    changed(entity, component) {
+      const id = componentId(component);
+      if ((owner.getComponentMutationEpochs()[id] ?? 0) <= acceptedEpoch) return false;
+      return (owner.getComponentChange(entity, id)?.changed ?? -1) > acceptedEpoch;
+    },
+    invalidate() {
+      readToken++;
+      invalid = true;
+    },
+    read() {
+      if (world.execution.health === 'poisoned')
+        throw new WorldPoisonedError(world.identity, world.execution.fault);
+      const token = ++readToken;
+      const epoch = owner.getMutationEpoch();
+      const structure = owner.getStructureEpoch();
+      const changedComponents = components.filter(
+        (component) =>
+          (owner.getComponentMutationEpochs()[componentId(component)] ?? 0) > acceptedEpoch,
+      );
+      const membershipChanged = invalid || structure !== acceptedStructure;
+      const changedRoots =
+        invalid ||
+        structure !== acceptedStructure ||
+        ids.some((id) => (owner.getComponentMutationEpochs()[id] ?? 0) > acceptedEpoch);
+      work.length = 0;
+      serial = (serial + 1) >>> 0;
+      if (serial === 0) {
+        stamp.fill(0);
+        serial = 1;
+      }
+      let scannedRows = 0;
+      let checkedBlocks = 0;
+      const updates: { table: Table; block: number; value: BlockBaseline | undefined }[] = [];
+      const visited = new Set<Table>();
+      if (changedRoots) {
+        const tables = new Set<Table>();
+        if (sparseCandidates) {
+          for (const table of graph.activeTables) tables.add(table);
+        } else {
+          for (const id of candidateIds)
+            for (const table of graph.activeTablesByComponent.get(id) ?? []) tables.add(table);
+        }
+        for (const table of tables) {
+          visited.add(table);
+          const prior = baseline.get(table);
+          const entities = table.storage.get(componentId(Entity))?.fields.get('self')?.view;
+          if (entities === undefined) continue;
+          const columns = ids.flatMap((id) => {
+            const epochs = table.storage.get(id)?.epochs;
+            return epochs === undefined ? [] : [epochs];
+          });
+          const blocks = Math.ceil(table.size / PROJECTION_BLOCK_SIZE);
+          for (let block = 0; block < blocks; block++) {
+            checkedBlocks++;
+            const previous = prior?.get(block);
+            const membership = table.membership[block] ?? 0;
+            const start = block * PROJECTION_BLOCK_SIZE;
+            const end = Math.min(table.size, start + PROJECTION_BLOCK_SIZE);
+            if (invalid || previous === undefined || previous.membership !== membership) {
+              if (previous !== undefined) {
+                for (const index of previous.ids) enqueue(index);
+                scannedRows += previous.ids.length;
+              }
+              const current = new Uint32Array(end - start);
+              for (let row = start; row < end; row++) {
+                const index = entityIndex(entities[row] as EntityHandle);
+                current[row - start] = index;
+                enqueue(index);
+              }
+              scannedRows += end - start;
+              updates.push({ table, block, value: { ids: current, membership } });
+            } else {
+              let changedBlock = false;
+              for (const column of columns) {
+                if ((column.blocks[block] ?? 0) <= acceptedEpoch) continue;
+                changedBlock = true;
+                for (let row = start; row < end; row++) {
+                  if ((column.changed[row] ?? 0) > acceptedEpoch)
+                    enqueue(entityIndex(entities[row] as EntityHandle));
+                }
+              }
+              if (!changedBlock) continue;
+              scannedRows += end - start;
+            }
+          }
+          if (prior !== undefined) {
+            for (const [block, previous] of prior) {
+              if (block < blocks) continue;
+              checkedBlocks++;
+              for (const index of previous.ids) enqueue(index);
+              scannedRows += previous.ids.length;
+              updates.push({ table, block, value: undefined });
+            }
+          }
+        }
+        for (const [table, prior] of baseline) {
+          if (visited.has(table)) continue;
+          for (const [block, previous] of prior) {
+            checkedBlocks++;
+            for (const index of previous.ids) enqueue(index);
+            scannedRows += previous.ids.length;
+            updates.push({ table, block, value: undefined });
+          }
+        }
+      }
+      let accepted = false;
+      const validate = (): void => {
+        if (world.execution.health === 'poisoned')
+          throw new WorldPoisonedError(world.identity, world.execution.fault);
+        if (
+          token !== readToken ||
+          epoch !== owner.getMutationEpoch() ||
+          structure !== owner.getStructureEpoch()
+        ) {
+          throw new StateProjectionExpiredError();
+        }
+      };
+      return {
+        indices: work,
+        epoch,
+        scannedRows,
+        checkedBlocks,
+        membershipChanged,
+        changedComponents,
+        validate,
+        accept() {
+          if (accepted) return;
+          validate();
+          for (const update of updates) {
+            let blocks = baseline.get(update.table);
+            if (update.value === undefined) {
+              blocks?.delete(update.block);
+              if (blocks?.size === 0) baseline.delete(update.table);
+            } else {
+              if (blocks === undefined) {
+                blocks = new Map();
+                baseline.set(update.table, blocks);
+              }
+              blocks.set(update.block, update.value);
+            }
+          }
+          acceptedEpoch = epoch;
+          acceptedStructure = structure;
+          invalid = false;
+          accepted = true;
+        },
+      };
+    },
+  };
+}

package/src/query/query.ts

@@ -24,7 +24,7 @@ import { DERIVED_WRITER } from '../internal';
 import { isRelationshipTarget, relationshipRole } from '../relationship-index';
 import type { Archetype, ArchetypeId } from '../storage/archetype';
 import type { ArchetypeGraph } from '../storage/archetype-graph';
-import { sparseTagIndex } from '../storage/change-detection';
+import { PROJECTION_BLOCK_SIZE, sparseTagIndex } from '../storage/change-detection';
 import type { FieldView, ManagedColumnReader } from '../storage/column';
 import type { Table } from '../storage/table';
 import { type WorldInternal, worldInternal } from '../world-internal';
@@ -206,21 +206,14 @@ class QueryRowFacade<
   }
 
   has(component: R[number] | W[number] | O[number]): boolean {
-    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<C extends R[number]>(component: C): ReadonlyRowShape<C>;
   get<C extends O[number]>(component: C): ReadonlyRowShape<C> | undefined;
   get(component: Component): Record<string, unknown> | undefined {
-    if (
-      !this.archetype?.components.some(
-        (candidate) => componentId(candidate) === componentId(component),
-      )
-    ) {
+    if (!this.has(component)) {
       return undefined;
     }
     const result = this.world[worldInternal].getQueryRow(this.entity, component);
@@ -370,8 +363,9 @@ class ExecutableQuery<
     const structureEpoch = this.world[worldInternal].getStructureEpoch();
     const upperBound = this.world[worldInternal].getMutationEpoch();
     const row = new QueryRowFacade<R, W, O>(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;
 
@@ -446,7 +440,7 @@ class ExecutableQuery<
   at(entity: EntityHandle): QueryRow<R, W, O> | undefined {
     const archetype = this.world[worldInternal].getEntityArchetype(entity);
     if (archetype === undefined || !this.archetypeMatches(archetype)) return undefined;
-    return new QueryRowFacade<R, W, O>(this.world).bind(entity, archetype).snapshot();
+    return new QueryRowFacade<R, W, O>(this.world).bind(entity, archetype);
   }
 
   spans(): Result<Iterable<QuerySpan<R, W>>, QuerySpanUnavailableError> {
@@ -459,7 +453,8 @@ class ExecutableQuery<
         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: boolean): void => {
@@ -498,7 +493,12 @@ class ExecutableQuery<
                 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;
@@ -594,6 +594,13 @@ class ExecutableQuery<
     };
   }
 
+  private hasUnchangedInput(): boolean {
+    const epochs = this.world[worldInternal].getComponentMutationEpochs();
+    // Changed predicates are conjunctive. One unchanged input proves the
+    // entire result empty without consulting any entity or table row.
+    return this.compiled.changedIds.some((id) => (epochs[id] ?? 0) <= this.lastObservedEpoch);
+  }
+
   private beginIteration(): void {
     if (this.active) throw new QueryIterationActiveError();
     this.active = true;

package/src/shared-ref-store.ts

@@ -52,7 +52,6 @@
 //
 // Release path (D-1 codes):
 //   - resolve(h): err(SharedRefReleasedError)        if payload absent.
-//   - markChanged(h): publish an in-place payload mutation to subscribers.
 //   - retain(h):  err(SharedRefReleasedError)        if payload absent.
 //   - release(h): err(SharedRefDoubleReleaseError, rc=0) on rc=0 input.
 //   - any(builtin slot): err(BuiltinSlotNotOwnedError) (D-15).
@@ -84,13 +83,6 @@ import {
   SharedRefStaleError,
 } from './errors.js';
 
-const SHARED_REF_RELEASE_EVIDENCE_CAPACITY = 4096;
-
-export interface SharedRefMutation {
-  readonly epoch: number;
-  readonly handle: number;
-}
-
 export interface SharedRefReleaseEvidence {
   readonly payload: unknown;
   readonly refcount: 0;
@@ -98,16 +90,6 @@ export interface SharedRefReleaseEvidence {
   readonly evidence: 'released';
 }
 
-/** Diagnostic history identifies releases without retaining external payloads. */
-export type SharedRefReleaseRecord = Omit<SharedRefReleaseEvidence, 'payload'> & {
-  readonly handle: number;
-};
-
-export interface SharedRefMutationRead {
-  readonly cursor: number;
-  readonly records: readonly SharedRefMutation[];
-}
-
 // MAX_SLOT is now imported from @forgeax/engine-types (codec SSOT, D-1).
 // The local constant is removed to avoid drift (AC-15).
 
@@ -127,8 +109,6 @@ export interface SharedRefMutationRead {
  *   - alloc(target, payload)        -> Handle<T, 'shared'> (rc=1)
  *   - intern(target, payload)        -> stable producer handle per target + object identity
  *   - resolve(handle)             -> Result<T, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>
- *   - markChanged(handle)         -> Result<void, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>
- *   - getMutationEpoch()          -> monotonic payload-mutation cursor
  *   - retain(handle)              -> Result<void, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>
  *   - release(handle)             -> Result<release evidence | undefined, ...>
  *   - refcount(handle)            -> number (0 == released; debug + tests)
@@ -144,10 +124,7 @@ export class SharedRefStore {
     { readonly target: string; readonly payload: object }
   >();
   private nextSlot = BUILTIN_BASE;
-  private mutationEpoch = 0;
   /** Latest published mutation epoch per live handle; not an event journal. */
-  private readonly mutationEpochs = new Map<number, number>();
-  private readonly releaseJournal: SharedRefReleaseRecord[] = [];
 
   /**
    * Generation table indexed by slot (D-6). Each entry tracks the current
@@ -261,36 +238,6 @@ export class SharedRefStore {
    * projections of shared payload data compare the monotonic epoch and
    * explicitly refresh instead of rescanning every payload each frame.
    */
-  markChanged<Target extends string>(
-    handle: Handle<Target, 'shared'>,
-  ): Result<void, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError> {
-    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(undefined);
-  }
-
-  /** Current upper bound for explicitly published payload mutations. */
-  getMutationEpoch(): number {
-    return this.mutationEpoch;
-  }
-
-  /** Read each live handle whose latest published mutation is after `cursor`. */
-  readChangesSince(cursor: number): SharedRefMutationRead {
-    const records: SharedRefMutation[] = [];
-    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
@@ -368,7 +315,6 @@ export class SharedRefStore {
     }
     this.refcounts.delete(raw);
     this.payloads.delete(raw);
-    this.mutationEpochs.delete(raw);
     // Gen increment + retire (AC-07): bump gen; once it would exceed MAX_GEN
     // (gen 255 is still usable; the bump to 256 triggers retire) the slot is
     // permanently retired — NOT pushed to freeSlots. This prevents handle
@@ -385,25 +331,9 @@ export class SharedRefStore {
       generation,
       evidence: 'released' as const,
     });
-    this.releaseJournal.push(
-      Object.freeze({
-        handle: raw,
-        refcount: 0 as const,
-        generation,
-        evidence: 'released' as const,
-      }),
-    );
-    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(): readonly SharedRefReleaseRecord[] {
-    return this.releaseJournal;
-  }
-
   /**
    * Return the current refcount for `handle`. Returns 0 for a released
    * (or never-allocated) slot. Primarily a debug + tests entry point;