@lukekaalim/act-recon 3.1.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @lukekaalim/act-recon
 
+## 4.0.0
+
+### Major Changes
+
+- Improve debugger support
+
+### Patch Changes
+
+- Updated dependencies
+  - @lukekaalim/act@4.2.0
+
 ## 3.1.0
 
 ### Minor Changes

package/algorithms.ts

@@ -1,4 +1,4 @@
-import { MagicError } from "@lukekaalim/act";
+export type ChangeEqualityTest<Prev, Next> = (prev: Prev, next: Next, prevIndex: number, nextIndex: number) => boolean;
 
 /**
  * ChangeReport
@@ -56,25 +56,3 @@ export class ChangeReport2 {
     return report;
   }
 }
-
-export type ChangeEqualityTest<Prev, Next> = (prev: Prev, next: Next, prevIndex: number, nextIndex: number) => boolean;
-
-export const first = <X, Y>(array: ReadonlyArray<X>, func: (value: X, index: number) => Y | null): Y | null => {
-  for (let i = 0; i < array.length; i++) {
-    const value = array[i];
-    const result = func(value, i);
-    if (result !== null)
-      return result;
-  }
-  return null;
-}
-
-export const last = <X, Y extends {}>(array: ReadonlyArray<X>, func: (value: X, index: number) => Y | null | false | undefined | 0): Y | null => {
-  for (let i = array.length - 1; i > 0; i--) {
-    const value = array[i];
-    const result = func(value, i);
-    if (result)
-      return result;
-  }
-  return null;
-}

package/commit.ts

@@ -1,5 +1,4 @@
 import { createId, Element, OpaqueID, specialNodeTypes, SuspendProps } from "@lukekaalim/act";
-import { createObjectPool } from "./pool";
 
 /**
  * A single consistent id representing a commit in the act tree.
@@ -86,16 +85,6 @@ export class CommitRef2 {
 }
 
 export class Commit2 {
-  static pool = () => createObjectPool<Commit2, ConstructorParameters<typeof Commit2>>(
-    function alloc (ref, el, ch) { return new Commit2(ref, el, ch) },
-    function reassign(c, ref, el, ch) {
-      c.ref = ref;
-      c.element = el;
-      c.children = ch;
-      c.version = createId('CommitVersion');
-    }
-  )
-
   ref: CommitRef2;
 
   element: Element;

package/delta.ts

@@ -1,6 +1,6 @@
 import { Element } from "@lukekaalim/act";
 import { Commit2, CommitID } from "./commit.ts";
-import { EffectID, EffectTask } from "./state.ts";
+import { EffectID, EffectTask, EffectTask2 } from "./state.ts";
 
 /**
  * The Delta class represents an accumulation
@@ -24,8 +24,7 @@ export class Delta {
   changed: Map<CommitID, { prev: Element, next: Commit2, moved: boolean }> = new Map();
   removed: Map<CommitID, Commit2> = new Map();
 
-  effects: Map<EffectID, EffectTask> = new Map();
-  cleanups: Map<EffectID, EffectTask> = new Map();
+  effects: Map<EffectID, EffectTask2> = new Map();
 
   get size() {
     return (
@@ -62,16 +61,9 @@ export class Delta {
     }
   }
 
-  addEffects(tasks: EffectTask[]) {
+  addEffects(tasks: EffectTask2[]) {
     for (const task of tasks) {
       this.effects.set(task.id, task);
     }
   }
-
-  addCleanups(tasks: EffectTask[]) {
-    for (const task of tasks) {
-      this.effects.delete(task.id);
-      this.cleanups.set(task.id, task);
-    }
-  }
 }

package/element.ts

@@ -9,7 +9,7 @@ import {
 } from "@lukekaalim/act";
 import { Commit2, CommitRef2 } from "./commit";
 import { loadHooks2 } from "./hooks";
-import { BoundaryState, ComponentState, ContextState, EffectTask } from "./state";
+import { BoundaryState, ComponentState, ContextState, EffectID, EffectTask, EffectTask2 } from "./state";
 import { keyedElementEqualityTest2, WorkTask } from "./update";
 import { ChangeReport2 } from "./algorithms";
 import { CommitTree2 } from "./tree";
@@ -40,8 +40,7 @@ export class ElementOutput2 {
    */
   updates: WorkTask[] = []
   
-  effects: null | EffectTask[] = null;
-  cleanups: null | EffectTask[] = null;
+  effects: null | EffectTask2[] = null;
 
   extraTargets: null | CommitRef2[] = null;
 
@@ -51,12 +50,9 @@ export class ElementOutput2 {
 
   processComponent(component: Component<{}>, element: Element, tree: CommitTree2, state: ComponentState) {
     this.element = element;
-    state.effectTasks = null;
     
     state.hookIndex = 0;
-    if (!state.hooks)
-      state.hooks = loadHooks2(tree.reconciler, state, this.ref);
-
+    state.hooks = loadHooks2(tree.reconciler, state, this);
 
     hookImplementation.useContext = state.hooks.useContext;
     hookImplementation.useEffect = state.hooks.useEffect;
@@ -76,10 +72,8 @@ export class ElementOutput2 {
         if (state.boundary)
           state.boundary.clearThrow(this.ref);
       }
-      this.effects = state.effectTasks;
       this.calculateDiff();
     } catch (thrownValue) {
-    
       if (!state.boundary) {
         const boundary = tree.findClosestBoundary(this.ref);
         if (!boundary)

package/events.ts

@@ -0,0 +1,25 @@
+/**
+ * A convenience interface to describe a series of functions that represent
+ * event handlers.
+ * 
+ * Only one function exists per "event" type, so this is simpler and more
+ * direction approach than an pub/sub architecture.
+ * 
+ * Often used in recon to avoid circular reference issues when initializing,
+ * as assigning the event bus can occur after all associated resources init properly.
+ * 
+ * A system that has a (writable) event bus often fills it with a stub implementation
+ * initially. The individual functions are readonly, so you should endeavour to replace
+ * the whole bus.
+ * 
+ * @example
+ * You have something that wants to listen for events, and something that
+ * emits them.
+ * ```ts
+ * const listener = new Listener();
+ * const emitter = new Emitter();
+ * 
+ * emitter.bus = listener.bus;
+ * ```
+ */
+export type EventBus<T extends { [K: string]: (...args: any[]) => void }> = { readonly [key in keyof T]: T[key] };

package/hooks.ts

@@ -11,29 +11,27 @@ import {
 import { ComponentState, EffectID, EffectTask } from "./state";
 import { CommitRef2 } from "./commit";
 import { Reconciler2 } from "./reconciler";
-import { last } from "./algorithms";
+import { ElementOutput2 } from "./element";
 
 /**
  * A fresh set of hook functions is created per component run.
  */
 export const loadHooks2 = (
   reconciler: Reconciler2,
-
   state: ComponentState,
-  ref: CommitRef2
+  output: ElementOutput2
 ): HookImplementation => {
-
   function useContext<T>(context: Context<T>): T {
     const stateIndex = state.hookIndex++;
 
     if (!state.providers.has(stateIndex)) {
-      const provider = ref.find(ref => {
+      const provider = output.ref.find(ref => {
         const provider = reconciler.tree.contexts.get(ref.id)
         if (provider && provider.contextId === context.id)
           return provider;
       })
       if (provider) {
-        provider.consumers.set(ref.id, ref);
+        provider.consumers.set(output.ref.id, output.ref);
       }
       state.providers.set(stateIndex, provider);
     }
@@ -58,7 +56,7 @@ export const loadHooks2 = (
         return;
       
       state.values.set(stateIndex, nextValue);
-      reconciler.render(ref);
+      reconciler.render(output.ref);
     };
     return [value, setValue];
   }
@@ -74,20 +72,13 @@ export const loadHooks2 = (
     const depsChanges = calculateDepsChange(prevDeps, deps)
     
     if (depsChanges) {
-      if (!state.effectTasks)
-        state.effectTasks = [];
+      if (!output.effects)
+        output.effects = [];
       
-      state.effectTasks.push({
+      output.effects.push({
         id: effectId,
-        ref,
-        func() {
-          const prevCleanup = state.cleanups.get(effectId);
-          if (prevCleanup) {
-            state.cleanups.delete(effectId);
-            prevCleanup();
-          }
-          state.cleanups.set(effectId, effect());
-        }
+        effect,
+        ref: output.ref,
       });
     }
   }

package/mod.ts

@@ -10,5 +10,4 @@ export * from './state';
 export * from './thread';
 export * from './tree';
 export * from './update';
-export * from './pool';
 export * from './internal';

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@lukekaalim/act-recon",
   "type": "module",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "main": "mod.ts",
   "dependencies": {
-    "@lukekaalim/act": "^4.1.0"
+    "@lukekaalim/act": "^4.2.0"
   }
 }

package/reconciler.ts

@@ -5,6 +5,7 @@ import { CommitTree2 } from "./tree";
 import { Scheduler } from "./scheduler";
 import { Delta } from "./delta";
 import { WorkTask } from "./update";
+import { EffectTask2 } from "./state";
 
 /**
  * The Reconciler Event Bus is a structure that contains callbacks
@@ -35,49 +36,26 @@ export class Reconciler2 {
   // in the future - maybe more than one thread?
   thread: WorkThread2;
 
-  pools = {
-    commit: Commit2.pool(),
-  }
-
-  constructor(scheduler: Scheduler) {
+  constructor(scheduler: Scheduler, { WorkThread = WorkThread2 }: { WorkThread?: typeof WorkThread2} = {}) {
     this.scheduler = scheduler;
     this.tree = new CommitTree2(this);
-    this.thread = new WorkThread2(this.tree);
+    this.thread = new WorkThread(this.tree);
 
-    this.scheduler.setCallbackFunc(() => this.work());
-    this.pools.commit.maxSize = 2048
-  }
+    this.thread.bus = {
+      render: (delta) => this.bus.render(delta)
+    }
 
-  startNewThread() {
-    this.thread = new WorkThread2(this.tree);
+    this.scheduler.setCallbackFunc(() => this.work());
   }
 
-  submitThread() {
-    const currentThread = this.thread;
-
-    this.startNewThread();
-
-    // send delta ready
-    this.bus.render(currentThread.delta);
-
-    // run effects
-    for (const cleanup of currentThread.delta.cleanups.values())
-      cleanup.func();
-    for (const effect of currentThread.delta.effects.values())
-      effect.func();
+  work() {
+    this.thread.work();
 
-    for (const remove of currentThread.delta.removed.values())
-      this.pools.commit.release(remove);
-  }
+    if (this.thread.done) 
+      this.thread.reset();
 
-  work() {
-    if (!this.thread.done) {
-      // do some work
-      this.thread.work();
+    if (this.thread.hasWork)
       this.scheduler.requestCallback();
-    } else {
-      this.submitThread()
-    }
   }
 
   mount(node: Node): CommitRef2 {

package/scheduler.ts

@@ -4,14 +4,31 @@
  * 
  * In practice, this will be backed by something
  * as simple as setTimeout, requestAnimationFrame
- * or even idleCallback.
+ * or even idleCallback - by the renderer, who
+ * knows a bit more about the current runtime
+ * environment (aka which callbacks are more
+ * suited for the task.)
  * 
  * It should have a bit of internal state - only
  * a single callback can be queued at once.
  */
 export type Scheduler = {
+  /**
+   * The scheduler will call a specific function when
+   * requested. This method provides that function.
+   * 
+   * If not set before the a callback is requested, nothing will
+   * happen (a noop is expected by default).
+   * 
+   * @param callback The function that the Scheduler will call when requested.
+   */
   setCallbackFunc(callback: () => void): void,
 
+  /**
+   * Request that (using whatever mechanism the implementer wants)
+   * the Callback Function be executed. It should not be called
+   * _immediately_, but after some amount of time.
+   */
   requestCallback(): void,
   cancelCallback(): void,
 

package/state.ts

@@ -1,5 +1,5 @@
 import { CommitID, CommitRef2 } from "./commit.ts";
-import { OpaqueID, Deps, EffectCleanup, ContextID, HookImplementation, createId, BoundaryProps } from '@lukekaalim/act';
+import { OpaqueID, Deps, EffectCleanup, ContextID, HookImplementation, createId, BoundaryProps, EffectConstructor } from '@lukekaalim/act';
 import { CommitTree2 } from "./tree.ts";
 
 export type HookID = number;
@@ -7,7 +7,24 @@ export type EffectID = OpaqueID<"EffectID">;
 export type EffectTask = {
   ref: CommitRef2,
   id: EffectID,
-  func: () => void,
+  func: EffectConstructor,
+}
+
+/**
+ * An instruction to perform the declared side effect,
+ * made by the referenced commit. If there are cleanups associated
+ * with this effect in the tree, they should be run first.
+ * 
+ * If the effect produces any cleanups, they should be added to the tree.
+ */
+export type EffectTask2 = {
+  id: EffectID,
+  ref: CommitRef2,
+  /**
+   * when "Effect" is null, the task should
+   * only run any cleanups associated with the effect.
+   */
+  effect: EffectConstructor | null,
 }
 
 export type ComponentState = {
@@ -17,12 +34,10 @@ export type ComponentState = {
 
   hookIndex: HookID,
   hooks: null | HookImplementation,
-  effectTasks: null | EffectTask[],
 
   values:   Map<HookID, unknown>;
   deps:     Map<HookID, Deps>;
   effects:  Map<HookID, EffectID>;
-  cleanups:  Map<HookID, EffectCleanup>;
 
   rejection: null | { value: unknown };
   boundary: null | BoundaryState;

package/thread.ts

@@ -1,11 +1,12 @@
-import { createId, Element } from "@lukekaalim/act";
+import { createId, Element, OpaqueID, primitiveNodeTypes } from "@lukekaalim/act";
 import { Commit2, CommitID, CommitRef2 } from "./commit.ts";
 import { Delta } from "./delta.ts";
 import { CommitTree2 } from "./tree.ts";
 import { WorkTask } from "./update.ts";
 import { EffectTask } from "./state.ts";
+import { ReconcilerEventBus } from "./reconciler.ts";
 
-export type WorkReason =
+export type WorkRequest =
   | { type: 'mount', element: Element, ref: CommitRef2 }
   | { type: 'unmount', ref: CommitRef2 }
   | { type: 'target', ref: CommitRef2 }
@@ -16,6 +17,26 @@ export type QueueResult =
   | 'existing-target'
   | 'existing-task'
 
+export type ThreadState = {
+  requests: WorkRequest[];
+  missedRequests: WorkRequest[];
+
+  mustRender: Set<CommitID>;
+  mustVisit: Set<CommitID>;
+  pendingTasks: WorkTask[];
+
+  missed: Set<CommitID>;
+  missedUnmount: Set<CommitID>;
+
+  visited: Set<CommitID>;
+
+  started: boolean;
+  submitted: boolean;
+
+  pass: number;
+  id: OpaqueID<"ThreadID">;
+}
+
 /**
  * A temporary data structure that carries the state of a
  * work-in-progress update to the tree.
@@ -31,7 +52,7 @@ export class WorkThread2 {
    * they record the "reason", so you can trace which effects
    * cause/contributed to this thread.
    */
-  reasons: WorkReason[] = [];
+  requests: WorkRequest[] = [];
   /**
    * A Map of every commit that NEEDS to be rendered if you visit them.
    * This is often for commits that explicitly need a re-render because
@@ -65,9 +86,7 @@ export class WorkThread2 {
 
   unmountMissed: Set<CommitID> = new Set();
 
-
-  errorNotifications: Map<CommitID, CommitRef2> = new Map();
-
+  requestsMissed: WorkRequest[] = [];
   /**
    * A list of each commit the thread processed
    */
@@ -78,12 +97,20 @@ export class WorkThread2 {
   id = createId("ThreadID")
   passes = 1;
 
+  /** Have we done any work yet? */
+  started = false;
+  /** Have we submitted our delta to the renderer? */
+  submitted = false;
+
   constructor(tree: CommitTree2) {
     this.tree = tree;
   }
 
   get done() {
-    return this.pendingTasks.length === 0 && this.missed.size === 0;
+    return this.started && !this.hasWork;
+  }
+  get hasWork() {
+    return this.pendingTasks.length > 0 || this.missed.size > 0 || (this.started && !this.submitted);
   }
 
   /**
@@ -94,11 +121,16 @@ export class WorkThread2 {
    * if the Thread has already rendered this element (you
    * have to queue it in the next thread)
    */
-  queue(reason: WorkReason): QueueResult {
+  queue(reason: WorkRequest): QueueResult {
+    if (this.submitted) {
+      this.requestsMissed.push(reason);
+      return 'missed';
+    }
+
     // We are very lazy in this function -  we only
     // want to create a new update at the worst possible
     // case
-    this.reasons.push(reason);
+    this.requests.push(reason);
 
     // Mounts are really easy - they never have any history, so
     // we don't need to check for conflicts.
@@ -177,7 +209,7 @@ export class WorkThread2 {
   createCommit(element: Element, ref: CommitRef2) {
     const output = this.tree.processElement(element, ref, null);
         
-    const commit = this.tree.reconciler.pools.commit.acquire(ref, element, output.childRefs);
+    const commit = new Commit2(ref, element, output.childRefs);
 
     this.tree.commits.set(commit.ref.id, commit);
     this.delta.add(commit);
@@ -187,7 +219,7 @@ export class WorkThread2 {
     if (output.effects)
       this.delta.addEffects(output.effects);
 
-    this.pendingTasks.push(...output.updates);
+    this.pendingTasks.push(...output.updates.toReversed());
   }
   updateCommit(commit: Commit2, element: Element, moved: boolean) {
     const output = this.tree.processElement(element, commit.ref, commit);
@@ -196,7 +228,7 @@ export class WorkThread2 {
     commit.update(element, output.childRefs);
     this.delta.update(oldElement, commit, moved);
 
-    this.pendingTasks.push(...output.updates);
+    this.pendingTasks.push(...output.updates.toReversed());
     if (output.effects)
       this.delta.addEffects(output.effects);
   }
@@ -208,16 +240,16 @@ export class WorkThread2 {
     if (commit.ref.length === 1)
       this.tree.roots.delete(commit.ref.id);
 
-    this.pendingTasks.push(...output.updates);
-    if (output.cleanups)
-      this.delta.addEffects(output.cleanups);
+    this.pendingTasks.push(...output.updates.toReversed());
+    if (output.effects)
+      this.delta.addEffects(output.effects);
   }
   skipCommit(commit: Commit2) {
     const prevChildren = commit.children
       .map(c => this.tree.commits.get(c.id) as Commit2);
 
     const updates = prevChildren.map(prev => WorkTask.visit(prev));  
-    this.pendingTasks.push(...updates);
+    this.pendingTasks.push(...updates.toReversed());
 
     commit.update();
   }
@@ -239,18 +271,23 @@ export class WorkThread2 {
   processTask(task: WorkTask) {
     const { next, prev, ref } = task;
 
-    const identicalChange = next && prev && (next.id === prev.element.id);
+    if (next && prev) {
+      let identicalChange = (
+        (next.id === prev.element.id)
+        || ((next.type === primitiveNodeTypes.string || next.type === primitiveNodeTypes.number) && next.props.value === prev.element.props.value)
+      );
 
-    if (identicalChange) {
-      const mustVisit = this.mustVisit.has(ref.id);
-      if (!mustVisit)
-        return;
+      if (identicalChange) {
+        const mustVisit = this.mustVisit.has(ref.id);
+        if (!mustVisit)
+          return;
 
-      const mustRender = this.mustRender.has(ref.id);
+        const mustRender = this.mustRender.has(ref.id);
 
-      if (!mustRender) {
-        this.skipCommit(prev)
-        return
+        if (!mustRender) {
+          this.skipCommit(prev)
+          return
+        }
       }
     }
     
@@ -259,11 +296,16 @@ export class WorkThread2 {
 
   work() {
     const task = this.pendingTasks.pop();
+
     if (task) {
+      this.started = true;
       this.processTask(task);
-      task.free();
-    } else if (!this.done) {
+    } else if (this.missed.size > 0) {
       this.startNextPass();
+    } else if (this.started && !this.submitted) {
+      this.submit();
+    } else {
+      console.info(`Work on thread was requested, but no work was needed`)
     }
   }
 
@@ -272,6 +314,7 @@ export class WorkThread2 {
     this.mustRender.clear();
     this.mustVisit.clear();
     this.visited.clear();
+    this.started = false
 
     this.passes++;
 
@@ -298,4 +341,41 @@ export class WorkThread2 {
     }
     this.missed.clear();
   }
+
+  /**
+   * Clear the thread of all work,
+   * except for any missed requests
+   */
+  reset() {
+    const missed = this.requestsMissed;
+
+    this.requests = [];
+    this.pendingTasks = [];
+    this.requestsMissed = [];
+
+    this.missed.clear();
+    this.mustRender.clear();
+    this.mustVisit.clear();
+    this.visited.clear();
+    this.delta = new Delta();
+
+    this.id = createId();
+    
+    this.passes = 1;
+
+    this.submitted = false;
+    this.started = false;
+
+    for (const request of missed)
+      this.queue(request);
+  }
+
+  bus = { render(delta: Delta): void {} }
+
+  submit() {
+    this.submitted = true;
+
+    this.bus.render(this.delta);
+    this.tree.runEffects(this.delta.effects);
+  }
 }

package/tree.ts

@@ -1,9 +1,14 @@
-import { ContextID, Element, specialNodeTypes } from "@lukekaalim/act";
+import { ContextID, EffectCleanup, EffectConstructor, Element, specialNodeTypes } from "@lukekaalim/act";
 import { Commit2, CommitID, CommitRef2 } from "./commit.ts";
 import { ElementOutput2 } from "./element.ts";
-import { BoundaryState, ComponentState, ContextState, EffectID } from "./state.ts";
+import { BoundaryState, ComponentState, ContextState, EffectID, EffectTask2 } from "./state.ts";
 import { Reconciler2 } from "./reconciler.ts";
-import { last } from "./algorithms.ts";
+
+export type EffectCleanupState = {
+  id: EffectID,
+  ref: CommitRef2,
+  func: EffectCleanup
+}
 
 /**
  * The CommitTree is responsible for keeping track
@@ -32,6 +37,8 @@ export class CommitTree2 {
   contexts: Map<CommitID, ContextState<unknown>> = new Map();
   boundaries: Map<CommitID, BoundaryState> = new Map();
 
+  cleanups: Map<EffectID, EffectCleanupState> = new Map();
+
   commits: Map<CommitID, Commit2> = new Map();
   roots: Set<CommitID> = new Set();
 
@@ -49,8 +56,6 @@ export class CommitTree2 {
         rejection: null,
         boundary: null,
         hooks: null,
-        effectTasks: [],
-        cleanups: new Map(),
         providers: new Map(),
         values: new Map(),
         deps: new Map(),
@@ -109,7 +114,6 @@ export class CommitTree2 {
     }
   }
 
-
   unmountCommit(prev: Commit2) {
     const output = new ElementOutput2(prev.ref);
     output.prevChildren = prev.children.map(c => this.commits.get(c.id) as Commit2);
@@ -140,15 +144,12 @@ export class CommitTree2 {
         if (componentState.boundary && componentState.rejection) {
           componentState.boundary.clearThrow(prev.ref);
         }
-        output.cleanups = [];
-        for (const [index, cleanup] of componentState.cleanups) {
-          if (!cleanup)
-            continue;
-          const id = componentState.effects.get(index) as EffectID;
-          output.cleanups.push({
-            id,
+        output.effects = [];
+        for (const effectId of componentState.effects.values()) {
+          output.effects.push({
+            id: effectId,
+            effect: null,
             ref: prev.ref,
-            func: cleanup
           });
         }
         this.components.delete(prev.ref.id);
@@ -198,5 +199,34 @@ export class CommitTree2 {
 
     return output;
   }
-}
 
+  runEffects(effects: ReadonlyMap<EffectID, EffectTask2>) {
+    // not every task actually has an effect - when
+    // a commit is unmounted with effects it generates
+    // a "teardown" task, which just runs the cleanup
+    const tasksWithEffects: EffectTask2[] = [];
+    
+    // We will do this in two passes - the first
+    // to run all potential "cleanups", which
+    // we don't really know until the last moment
+    // if one exists.
+    for (const task of effects.values()) {
+      const cleanupState = this.cleanups.get(task.id);
+      if (cleanupState) {
+        cleanupState.func();
+        this.cleanups.delete(task.id);
+      }
+      if (task.effect)
+        tasksWithEffects.push(task);
+    }
+
+    // The second pass actually runs the effects
+    for (const task of tasksWithEffects) {
+      // (we already checked in the previous loop)
+      const cleanup = (task.effect as EffectConstructor)();
+      if (cleanup) {
+        this.cleanups.set(task.id, { id: task.id, ref: task.ref, func: cleanup });
+      }
+    }
+  }
+}

package/update.ts

@@ -1,7 +1,6 @@
-import { convertNodeToElements, createId, Element, Node, specialNodeTypes } from "@lukekaalim/act";
-import { ChangeEqualityTest, ChangeReport2 } from "./algorithms.ts";
-import { Commit2, CommitID, CommitRef2 } from "./commit.ts";
-import { createObjectPool, ObjectPool } from "./pool.ts";
+import { Element, specialNodeTypes } from "@lukekaalim/act";
+import { ChangeEqualityTest } from "./algorithms.ts";
+import { Commit2, CommitRef2 } from "./commit.ts";
 
 /**
  * A request to transform part of a tree specified by
@@ -9,16 +8,6 @@ import { createObjectPool, ObjectPool } from "./pool.ts";
  * request
  */
 export class WorkTask {
-  static pool = createObjectPool<WorkTask, Parameters<typeof this.new>>(
-    (ref, prev, next, moved) => new WorkTask(ref, prev,  next, moved),
-    (task, ref, prev, next, moved = false) => {
-      task.ref = ref;
-      task.prev = prev;
-      task.next = next;
-      task.moved = moved;
-    }
-  )
-
   /**
    * The commit that should evaluate this
    * update (if this commit does not exist,
@@ -27,7 +16,8 @@ export class WorkTask {
   ref: CommitRef2;
 
   /** If null, this update should cause
-   * this commit to be created */
+   * this commit to be created
+   * */
   prev: null | Commit2;
   /** If null, this update should cause
    * this commit to be removed
@@ -44,12 +34,8 @@ export class WorkTask {
     this.moved = moved;
   }
 
-  free() {
-    WorkTask.pool.release(this);
-  }
-
   private static new(ref: CommitRef2, prev: null | Commit2, next: null | Element, moved: boolean = false) {
-    return this.pool.acquire(ref, prev, next, moved)
+    return new WorkTask(ref, prev, next, moved)
   }
 
   static fresh(ref: CommitRef2, next: Element) {

package/pool.ts

@@ -1,48 +0,0 @@
-
-/**
- * A short utility for re-using old objects
- * to avoid doing too much GC thrashing, at the
- * cost of increased memory.
- * 
- * Don't know yet if the trade off it worth it.
- */
-export type ObjectPool<T, TArgs extends unknown[]> = {
-  maxSize: number,
-  size: number,
-
-  all: T[],
-  available: T[],
-
-  acquire(...args: TArgs): T,
-  release(value: T): void,
-}
-
-export const createObjectPool = <T, TArgs extends unknown[]>(
-  build: (...args: TArgs) => T,
-  assign: (value: T, ...args: TArgs) => void,
-): ObjectPool<T, TArgs> => {
-  const pool = {
-    maxSize: 256,
-    available: [] as T[],
-    all: [] as T[],
-    get size() {
-      return pool.available.length;
-    },
-    acquire(...args: TArgs): T {
-      let object = pool.available.pop();
-      if (!object) {
-        object = build(...args);
-        pool.all.push(object);
-        return object;
-      }
-
-      assign(object, ...args);
-      return object;
-    },
-    release(value: T) {
-      //if (pool.size < pool.maxSize)
-      pool.available.push(value);
-    }
-  }
-  return pool;
-}