informa 4.0.1 → 5.0.0

package/src/low.ts

@@ -5,6 +5,7 @@ import { isListInGrid } from "./utils.js";
 import { EnumerableWeakMap } from "./EnumerableWeakMap.js";
 import { StatifiedMap } from "./quirks/map.js";
 import { StatifiedArray } from "./quirks/array.js";
+import { clearPendingAssemblies } from "./quirks/basestatified.js";
 
 type ProxyEventEmitterEvents = {
   "set": [any],
@@ -157,30 +158,15 @@ export type Statified<T extends StatifiableProp> = T extends object
       : Statify<{ [K in keyof T]: Statified<T[K]> }>
   : T;
 
-/**
- * Emit the appropriate structural events when a field transitions from `old` to
- * `next`. Called after unhook/hook so the event graph is already up-to-date.
- *
- * Rules:
- *  Set  → Set   : symmetric diff (deleteItem for removed, addItem for added)
- *  Set  → other : wipe old set (deleteItem every item)
- *  other→ Set   : introduce new set (addItem every item)
- *  Array→ other : wipe old array (spliceOutElement every item)
- *  other→ Array : introduce new array (spliceInElement every item)
- *  Map  → Map   : diff entries (deleteEntry, replaceEntry, addEntry)
- *  Map  → other : wipe old map (deleteEntry every entry)
- *  other→ Map   : introduce new map (addEntry every entry)
- */
 export function emitCollectionTransition(old: unknown, next: unknown): void {
-  const oldIsSet   = old  != null && typeof old  === "object" && (old  as any)[isStatifiedSetKey];
-  const nextIsSet  = next != null && typeof next === "object" && (next as any)[isStatifiedSetKey];
-  const oldIsArray = old  != null && typeof old  === "object" && (old  as any)[isStatifiedArrayKey];
-  const nextIsArray= next != null && typeof next === "object" && (next as any)[isStatifiedArrayKey];
-  const oldIsMap   = old  != null && typeof old  === "object" && (old  as any)[isStatifiedMapKey];
-  const nextIsMap  = next != null && typeof next === "object" && (next as any)[isStatifiedMapKey];
-
-  // ---- Set transitions ----
-  if (oldIsSet && nextIsSet) {
+  const oldIsSet    = old  != null && typeof old  === "object" && (old  as any)[isStatifiedSetKey];
+  const nextIsSet   = next != null && typeof next === "object" && (next as any)[isStatifiedSetKey];
+  const oldIsArray  = old  != null && typeof old  === "object" && (old  as any)[isStatifiedArrayKey];
+  const nextIsArray = next != null && typeof next === "object" && (next as any)[isStatifiedArrayKey];
+  const oldIsMap    = old  != null && typeof old  === "object" && (old  as any)[isStatifiedMapKey];
+  const nextIsMap   = next != null && typeof next === "object" && (next as any)[isStatifiedMapKey];
+
+  if (oldIsSet && nextIsSet && old !== next) {
     const oldSet  = old  as StatifiedSet<unknown>;
     const nextSet = next as StatifiedSet<unknown>;
     const oldMeta = getMetadataOf(oldSet as Statify<{}>);
@@ -193,15 +179,13 @@ export function emitCollectionTransition(old: unknown, next: unknown): void {
     }
     if (changed) oldMeta.emit("cardChanged");
     return;
-  }
-  if (oldIsSet) {
+  } else if (oldIsSet) {
     const oldSet  = old as StatifiedSet<unknown>;
     const oldMeta = getMetadataOf(oldSet as Statify<{}>);
     let changed = false;
     for (const item of oldSet) { oldMeta.emit("deleteItem", item); changed = true; }
     if (changed) oldMeta.emit("cardChanged");
-  }
-  if (nextIsSet) {
+  } else if (nextIsSet) {
     const nextSet  = next as StatifiedSet<unknown>;
     const nextMeta = getMetadataOf(nextSet as Statify<{}>);
     let changed = false;
@@ -209,30 +193,30 @@ export function emitCollectionTransition(old: unknown, next: unknown): void {
     if (changed) nextMeta.emit("cardChanged");
   }
 
-  // ---- Array transitions ----
-  if (oldIsArray && !nextIsArray) {
-    const oldArr  = old as StatifiedArray<unknown>;
-    const oldMeta = getMetadataOf(oldArr as Statify<{}>);
-    if (oldArr.length > 0) {
-      for (let i = oldArr.length - 1; i >= 0; i--) {
-        oldMeta.emit("spliceOutElement", oldArr[i], i);
+  if (old !== next) {
+    if (oldIsArray) {
+      const oldArr  = old as StatifiedArray<unknown>;
+      const oldMeta = getMetadataOf(oldArr as Statify<{}>);
+      if (oldArr.length > 0) {
+        for (let i = oldArr.length - 1; i >= 0; i--) {
+          oldMeta.emit("spliceOutElement", oldArr[i], i);
+        }
+        oldMeta.emit("lengthChanged");
       }
-      oldMeta.emit("lengthChanged");
     }
-  }
-  if (nextIsArray && !oldIsArray) {
-    const nextArr  = next as StatifiedArray<unknown>;
-    const nextMeta = getMetadataOf(nextArr as Statify<{}>);
-    if (nextArr.length > 0) {
-      for (let i = 0; i < nextArr.length; i++) {
-        nextMeta.emit("spliceInElement", nextArr[i], i);
+    if (nextIsArray) {
+      const nextArr  = next as StatifiedArray<unknown>;
+      const nextMeta = getMetadataOf(nextArr as Statify<{}>);
+      if (nextArr.length > 0) {
+        for (let i = 0; i < nextArr.length; i++) {
+          nextMeta.emit("spliceInElement", nextArr[i], i);
+        }
+        nextMeta.emit("lengthChanged");
       }
-      nextMeta.emit("lengthChanged");
     }
   }
 
-  // ---- Map transitions ----
-  if (oldIsMap && nextIsMap) {
+  if (oldIsMap && nextIsMap && old !== next) {
     const oldMap  = old  as StatifiedMap<unknown, unknown>;
     const nextMap = next as StatifiedMap<unknown, unknown>;
     const oldMeta = getMetadataOf(oldMap as Statify<{}>);
@@ -246,15 +230,13 @@ export function emitCollectionTransition(old: unknown, next: unknown): void {
     }
     if (changed) oldMeta.emit("sizeChanged");
     return;
-  }
-  if (oldIsMap) {
+  } else if (oldIsMap) {
     const oldMap  = old as StatifiedMap<unknown, unknown>;
     const oldMeta = getMetadataOf(oldMap as Statify<{}>);
     let changed = false;
     for (const [k, v] of oldMap) { oldMeta.emit("deleteEntry", k, v); changed = true; }
     if (changed) oldMeta.emit("sizeChanged");
-  }
-  if (nextIsMap) {
+  } else if (nextIsMap) {
     const nextMap  = next as StatifiedMap<unknown, unknown>;
     const nextMeta = getMetadataOf(nextMap as Statify<{}>);
     let changed = false;
@@ -440,16 +422,8 @@ export function extract(
   });
 }
 
-const preExtractionHooks = new Set<() => void>();
-export function registerPreExtractionHook(fn: () => void): () => void {
-  preExtractionHooks.add(fn);
-  return () => preExtractionHooks.delete(fn);
-}
-
 export function selectorToRootAndPath(selector: () => Statify<StatifiableObj>) {
-  // Reconcile all pending class instances before entering extract-proxy-path mode.
-  // This ensures field accessors are installed so path extraction resolves correctly.
-  for (const hook of preExtractionHooks) hook();
+  clearPendingAssemblies();
 
   setGlobalStateMode("extract-proxy-path");
 

package/src/quirks/basestatified.ts

@@ -1,11 +1,8 @@
-import { EnumerableWeakMap } from "../EnumerableWeakMap.js";
 import { EnumerableWeakSet } from "../EnumerableWeakSet.js";
 import {
   exitProxySymbol,
   getMetadataOf,
   getGlobalStateMode,
-  isStatified,
-  metadataMap,
   setMetadataOf,
   statifySealKey,
   type Statify,
@@ -15,7 +12,6 @@ import {
   emitCollectionTransition,
   extract,
   hook,
-  registerPreExtractionHook,
   StateMetadata,
   unhook,
   type StatifiableObj,
@@ -23,14 +19,8 @@ import {
 
 type ClassType<T extends any[] = any[], U = object> = new (...args: T) => U;
 
-// Classes whose instances have been constructed but not yet field-instrumented.
 const pendingAssemblies = new EnumerableWeakSet<object>();
 
-// Map from a still-pending child instance → list of (parentMetadata, prop) pairs
-// that need hook() called once the child is reconciled.
-const deferredHooks = new EnumerableWeakMap<object, { metadata: StateMetadata; prop: string | symbol }[]>();
-
-// One shim proxy per outermost constructor (new.target).
 const shimCache = new WeakMap<Function, object>();
 
 function getPrototypeChainDescriptor(
@@ -46,295 +36,176 @@ function getPrototypeChainDescriptor(
   return undefined;
 }
 
-const shimHandler: ProxyHandler<object> = {
-  get(target, prop, recv) {
-    // Always signal that this object is statified.
-    if (prop === statifySealKey) return true;
+function clearAssembly(assembly: object) {
+  for (const key of Reflect.ownKeys(assembly)) {
+    const value = Reflect.get(assembly, key);
 
-    if (getGlobalStateMode() === "extract-proxy-path") {
-      // Root-level exit: this instance IS the stateRoot.
-      if (prop === exitProxySymbol) {
-        return { path: [], stateRoot: recv as Statify<StatifiableObj> };
-      }
+    Reflect.deleteProperty(assembly, key);
 
-      // Safety net: reconcile if somehow still pending at extraction time.
-      if (pendingAssemblies.has(recv as object)) {
-        reconcileInstance(recv as object);
-      }
+    (assembly as Record<string | symbol, unknown>)[key] = value;
+  }
 
-      // Forward to extract() so the path is captured.
-      // Own accessor properties on recv are already handling extract-proxy-path
-      // themselves; the shim is only reached for prototype-level props.
-      return extract(
-        Reflect.get(target, prop, recv),
-        recv as Statify<StatifiableObj>,
-        [prop],
-      );
-    }
+  console.log(Reflect.ownKeys(assembly));
 
-    return Reflect.get(target, prop, recv);
-  },
-
-  set(target, prop, newVal, recv) {
-    // This trap fires only when `prop` is NOT an own property of `recv`.
-    // That covers:
-    //   (a) Pre-reconciliation field initializer writes → create own data prop.
-    //   (b) Prototype accessor writes (e.g. `get state()` / `set state()`).
-    //   (c) Genuinely new dynamic property additions.
-    //
-    // Own accessor properties installed by reconcileInstance are handled
-    // by their own setters and never reach here.
-
-    // Check for a prototype-level accessor setter BEFORE calling Reflect.set.
-    const protoDesc = getPrototypeChainDescriptor(target, prop);
-
-    // Delegate the actual assignment.
-    const result = Reflect.set(target, prop, newVal, recv);
-
-    // If this was a prototype accessor write and the instance has metadata,
-    // emit replacement events so subscribers fire.
-    if (result && protoDesc?.set && metadataMap.has(recv as Statify<StatifiableObj>)) {
-      const stateMetadata = getMetadataOf(recv as Statify<StatifiableObj>);
-      stateMetadata.emit("replaceProp", newVal, prop);
-      const ee = stateMetadata.eventEmitterAtPathMaybe([prop]);
-      if (ee) {
-        ee.emit("replace", newVal);
-        emitDescendantPathEvents(stateMetadata, [prop], newVal, true);
-      }
-    }
+  pendingAssemblies.delete(assembly);
+}
 
-    return result;
-  },
-
-  has(target, prop) {
-    if (prop === statifySealKey || prop === exitProxySymbol) return true;
-    return Reflect.has(target, prop);
-  },
-};
-
-function getOrCreateShim(ctor: Function): object {
-  const cached = shimCache.get(ctor);
-  if (cached) return cached;
-
-  // shimTarget's [[Prototype]] = ctor.prototype, so the full chain is:
-  //   instance → shim → shimTarget → ctor.prototype → … → Superclass.prototype
-  // This preserves instanceof for all classes in the chain.
-  const shimTarget = Object.create((ctor as ClassType).prototype) as object;
-  const shim = new Proxy(shimTarget, shimHandler);
-  shimCache.set(ctor, shim);
-  return shim;
+export function clearPendingAssemblies() {
+  for (const assembly of pendingAssemblies) {
+    clearAssembly(assembly);
+  }
 }
 
-/**
- * Converts all enumerable, configurable own data properties of `instance` into
- * accessor-backed reactive properties connected to `instance`'s StateMetadata.
- *
- * Idempotent: returns immediately if the instance is not in pendingAssemblies.
- */
-function reconcileInstance(instance: object): void {
-  if (!pendingAssemblies.has(instance)) return;
-  pendingAssemblies.delete(instance);
-
-  // Drain any deferred hooks where this instance was the pending child.
-  const deferred = deferredHooks.get(instance);
-  if (deferred) {
-    deferredHooks.delete(instance);
-    const childMetadata = getMetadataOf(instance as Statify<StatifiableObj>);
-    for (const { metadata: parentMetadata, prop } of deferred) {
-      hook(parentMetadata, prop, childMetadata);
-    }
+export function makeStatified<
+  StateLayer extends object,
+>(
+  Superclass: ClassType<any[], object>,
+): typeof Superclass & ClassType<any[], Statify<StateLayer>> {
+
+  if (shimCache.has(Superclass)) {
+    return shimCache.get(Superclass) as typeof Superclass & ClassType<any[], Statify<StateLayer>>;
   }
 
-  // Metadata was installed eagerly in ExtractionShimBase's constructor.
-  const metadata = getMetadataOf(instance as Statify<StatifiableObj>);
+  const dataLayers = new WeakMap<object, object>();
+
+  const ExtractionShimBase = function (...args: typeof Superclass extends ClassType<infer Args, object> ? Args : never) {
+    const inst = Reflect.construct(Superclass, args, new.target);
+
+    if (!pendingAssemblies.has(inst)) {
+      setMetadataOf(
+        inst as unknown as Statify<StatifiableObj>,
+        new StateMetadata(),
+      );
+      pendingAssemblies.add(inst);
+    }
 
-  const isArray = Array.isArray(instance);
+    queueMicrotask(() => {
+      clearPendingAssemblies();
+    });
 
-  const props: (string | symbol)[] = [
-    ...Object.getOwnPropertyNames(instance),
-    ...Object.getOwnPropertySymbols(instance),
-  ];
+    const proto = new Proxy({}, {
+      get(target, prop, receiver) {
+        const result = Reflect.get(target, prop, receiver);
 
-  for (const prop of props) {
-    // Skip Informa internal symbols.
-    if (prop === statifySealKey || prop === exitProxySymbol) continue;
+        if (getGlobalStateMode() === "extract-proxy-path") {
+          if (prop === exitProxySymbol) {
+            return { path: [], stateRoot: receiver };
+          }
 
-    // Skip array numeric indices — managed by the array's own push/pop/splice overrides.
-    if (isArray && typeof prop === "string" && Number.isInteger(Number(prop))) continue;
+          return extract(result, receiver, [prop]);
+        }
 
-    const desc = Object.getOwnPropertyDescriptor(instance, prop)!;
+        return result;
+      },
+    });
 
-    // Non-configurable: cannot be redefined; leave non-reactive.
-    // Note: these properties retain their value but won't participate in the
-    // observable graph. This is intentional and tested.
-    if (!desc.configurable) continue;
+    Reflect.setPrototypeOf(proto, Reflect.getPrototypeOf(inst))
 
-    // Existing accessor (get/set): do not double-wrap.
-    if ("get" in desc || "set" in desc) continue;
+    Reflect.setPrototypeOf(inst, proto);
 
-    // ---- Instrument this configurable data property ----
-    let value: unknown = desc.value;
+    dataLayers.set(inst, {});
 
-    // Hook the initial value if it is itself statified.
-    if (
-      value != null &&
-      typeof value === "object" &&
-      isStatified(value as StatifiableObj)
-    ) {
-      if (pendingAssemblies.has(value as object)) {
-        // The nested value is itself pending (constructed during this constructor
-        // but not yet reconciled — its metadata doesn't exist yet). Defer the
-        // hook: it will be wired once reconcileInstance runs for that child.
-        deferredHooks.getOrInsertComputed(value as object, () => []).push({ metadata, prop });
+    return inst;
+  }
+
+  ExtractionShimBase.prototype = new Proxy({}, {
+    get(target, prop, recv) {
+      return Reflect.has(dataLayers.get(recv)!, prop)
+        ? Reflect.get(dataLayers.get(recv)!, prop)
+        : Reflect.get(target, prop, recv);
+    },
+
+    set(target, prop, newVal, recv) {
+      const stateMetadata = getMetadataOf(recv);
+
+      const had = Reflect.has(recv, prop);
+      const oldVal = Reflect.get(recv, prop) as unknown;
+
+      let result;
+      const desc = getPrototypeChainDescriptor(target, prop);
+      if (desc?.set || desc?.get) {
+        result = Reflect.set(target, prop, newVal, recv);
+      } else if (typeof prop === "string" && prop.startsWith("#")) {
+        result = Reflect.set(target, prop, newVal, recv);
       } else {
-        hook(metadata, prop, getMetadataOf(value as Statify<StatifiableObj>));
+        result = Reflect.set(dataLayers.get(recv)!, prop, newVal);
       }
-    }
 
-    Object.defineProperty(instance, prop, {
-      get(this: object) {
-        if (getGlobalStateMode() === "extract-proxy-path") {
-          return extract(value, this as Statify<StatifiableObj>, [prop]);
+      if (result) {
+        if (
+          oldVal !== newVal
+          && typeof newVal === "object"
+          && newVal != null
+          && newVal[statifySealKey]
+        ) {
+          const newValMetadata = getMetadataOf(newVal as Statify<StatifiableObj>);
+
+          hook(stateMetadata, prop, newValMetadata);
         }
-        return value;
-      },
 
-      set(this: object, next: unknown) {
-        const old = value;
-        value = next;
+        if (had) {
+          if (
+            oldVal !== newVal
+            && typeof oldVal === "object"
+            && oldVal != null
+            && (oldVal as any)[statifySealKey]
+          ) {
+            const oldValMetadata = getMetadataOf(oldVal as Statify<StatifiableObj>);
+
+            unhook(stateMetadata, prop, oldValMetadata);
+          }
+
+          emitCollectionTransition(oldVal, newVal);
 
-        if (old !== next) {
           if (
-            old != null &&
-            typeof old === "object" &&
-            isStatified(old as StatifiableObj)
+            typeof prop !== "symbol" &&
+            Number.isInteger(Number(prop)) &&
+            Array.isArray(target)
           ) {
-            unhook(metadata, prop, getMetadataOf(old as Statify<StatifiableObj>));
+            stateMetadata.emit('replaceElement', newVal, Number(prop));
           }
 
+          stateMetadata.emit('replaceProp', newVal, prop);
+        } else {
           if (
-            next != null &&
-            typeof next === "object" &&
-            isStatified(next as StatifiableObj)
+            typeof prop !== "symbol" &&
+            Number.isInteger(Number(prop)) &&
+            Array.isArray(target)
           ) {
-            hook(metadata, prop, getMetadataOf(next as Statify<StatifiableObj>));
+            stateMetadata.emit('spliceInElement', newVal, Number(prop));
           }
 
-          emitCollectionTransition(old, next);
+          stateMetadata.emit('addProp', newVal, prop);
         }
 
-        // Enter the existing replacement machinery — same path as statifyObject's
-        // set trap in low.ts. "listen → replace → fire" is preserved because this
-        // accessor is installed before any external mutation can reach the field.
-        metadata.emit("replaceProp", next, prop);
+        stateMetadata.emit('setProp', newVal, prop);
 
-        const ee = metadata.eventEmitterAtPathMaybe([prop]);
-        if (ee) {
-          ee.emit("replace", next);
-          emitDescendantPathEvents(metadata, [prop], next, true);
-        }
-      },
+        const maybeEventEmitterAtVal = stateMetadata.eventEmitterAtPathMaybe([prop]);
+        if (maybeEventEmitterAtVal) {
+          if (had) {
+            maybeEventEmitterAtVal.emit('replace', newVal);
+          }
 
-      enumerable: desc.enumerable ?? true,
-      configurable: true,
-    });
-  }
+          maybeEventEmitterAtVal.emit('set', newVal);
 
-  // Selector/stateRoot identity: verified correct. Every on*()/off*() call goes
-  // through selectorToRootAndPath(), which fires preExtractionHooks() before
-  // entering extract-proxy-path mode. The preExtractionHook registered below
-  // reconciles all pending instances first — so by the time the selector function
-  // runs, every pending `this.x` field is already an accessor that returns
-  // extract(value, this, ['x']). Path chains like `() => this.a.b.c` are therefore
-  // built up correctly, and stateRoot is the raw instance, which is the same object
-  // keyed in metadataMap. No re-mapping needed.
-}
+          emitDescendantPathEvents(
+            stateMetadata,
+            [prop],
+            newVal,
+            had,
+          );
+        }
+      }
 
-// Before selectorToRootAndPath enters extract-proxy-path mode it calls all
-// registered hooks. This hook reconciles every pending instance so that their
-// own data properties are already accessor-backed when the selector runs.
+      return result;
+    },
+  });
 
-registerPreExtractionHook(() => {
-  // Snapshot: reconcileInstance removes from pendingAssemblies, which mutates
-  // the set during iteration — take a copy first.
-  const snapshot = [...pendingAssemblies];
-  for (const instance of snapshot) {
-    reconcileInstance(instance);
-  }
-});
-
-/**
- * Wraps a user-defined class factory in the Informa observable lifecycle.
- *
- * Usage:
- * ```ts
- * const MyClass = statifyClass(
- *   (Base) => class MyClass extends Base {
- *     name = "default";
- *     constructor(name: string) { super(); this.name = name; }
- *   },
- *   Object,
- * );
- * ```
- *
- * Construction lifecycle:
- *   1. ExtractionShimBase constructor runs → metadata installed, shim set as prototype.
- *   2. UserSubclass field initializers run → own data properties created on instance.
- *   3. UserSubclass constructor body runs.
- *   4. Instance is in pendingAssemblies (field instrumentation deferred).
- *   5. On first `on()`/`off()` call → registerPreExtractionHook fires → reconcileInstance
- *      converts own data properties to reactive accessor-backed properties.
- */
-export function statifyClass<
-  SubclassType extends ClassType<ArgsSub, OutSub>,
-  ArgsSub extends any[],
-  OutSub extends object,
-  SuperclassType extends ClassType<ArgsSuper, OutSuper>,
-  ArgsSuper extends any[],
-  OutSuper extends object,
->(
-  makeSubclass: (SuperclassIn: SuperclassType) => SubclassType,
-  Superclass: SuperclassType,
-): SubclassType & ClassType<ArgsSub, Statify<OutSub>> {
-
-  // ExtractionShimBase sits between Superclass and the user's class.
-  // Its constructor:
-  //   - Installs StateMetadata on the instance eagerly (so subclasses like
-  //     StatifiedArray can call getMetadataOf() from their constructor bodies).
-  //   - Marks the instance as pending for lazy field instrumentation.
-  //   - Inserts the shim proxy as the instance's [[Prototype]], enabling
-  //     statifySealKey / exitProxySymbol / extract-proxy-path handling.
-  //
-  // Guard: in nested statifyClass chains (e.g. statifyClass(..., A) where A
-  // was itself produced by statifyClass), multiple ExtractionShimBase
-  // constructors run. The guard ensures setup happens exactly once — at the
-  // innermost (deepest) ExtractionShimBase call.
-  class ExtractionShimBase extends (Superclass as unknown as typeof Object) {
-    constructor(...args: any[]) {
-      super(...(args as []));
-
-      if (!pendingAssemblies.has(this)) {
-        setMetadataOf(
-          this as unknown as Statify<StatifiableObj>,
-          new StateMetadata(),
-        );
-        pendingAssemblies.add(this);
-      }
+  Reflect.setPrototypeOf(ExtractionShimBase.prototype, Superclass.prototype);
 
-      // Always update the shim to match the outermost constructor (new.target).
-      // In nested chains the innermost ExtractionShimBase sets the shim first;
-      // subsequent (shallower) ones overwrite it with the same value since
-      // new.target propagates as the outermost class throughout the chain.
-      const ctor = (new.target ?? ExtractionShimBase) as Function;
-      Reflect.setPrototypeOf(this, getOrCreateShim(ctor));
-    }
-  }
+  shimCache.set(Superclass, ExtractionShimBase);
 
-  // Invoke the user's factory with the shim base, then return the result.
-  // No outer Statified wrapper is needed: field instrumentation is lazy,
-  // triggered by registerPreExtractionHook before any selectorToRootAndPath call.
-  return makeSubclass(
-    ExtractionShimBase as unknown as SuperclassType,
-  ) as unknown as SubclassType & ClassType<ArgsSub, Statify<OutSub>>;
+  return ExtractionShimBase as unknown as typeof Superclass & ClassType<any[], Statify<StateLayer>>;
 }
 
+export const makeBaseStatified = <T extends object>() => makeStatified<T>(Object);

package/src/test.ts

@@ -1,4 +1,5 @@
 import $ from "./high.js";
+import { makeStatified } from "./quirks/basestatified.js";
 import { StatifiedSet } from "./quirks/set.js";
 
 const stateful = $.state<{ a: ({ d: number })[], b?: { c?: { d?: Set<number> } } }>({ a: [] });
@@ -26,19 +27,21 @@ const asdf2 = $.state({ c: asdf });
 // const aassddff = $.state(new Set());
 stateful.b = asdf2;
 
-const Wayland = $.statifyClass(
-  (Base) => class Wayland extends Base {
-    displays = new StatifiedSet();
+interface WaylandState {
+  state2: number;
+}
+class Wayland extends makeStatified<WaylandState>(Object) {
+  displays = new StatifiedSet();
 
-    #state = 0;
-    get state() { return this.#state; }
-    set state(v: number) {
-      console.log("set", v);
-      this.#state = v;
-    }
-  },
-  Object,
-);
+  state = 10;
+
+  get state2() {
+    return super.state2;
+  }
+  set state2(v) {
+    super.state2 = v;
+  }
+}
 
 const w = new Wayland();
 $.onSet(() => w.state, (v) => console.log("asdf awawa!!", v));
@@ -47,6 +50,12 @@ $.onSet(() => w.state, (v) => console.log("asdf awawa!!", v));
 w.state = 6;
 w.state = 7;
 
+$.onSet(() => w.state2, (v) => console.log("asdf awawa!!", v));
+
+// w.state2 = 5;
+w.state2 = 1234;
+w.state2 = 12345;
+
 const map = $.state<Map<number, string>>(new Map());
 $.onSetEntry(() => map, (k, v) => console.log("set", k, v));
 $.onReplaceEntry(() => map, (k, v) => console.log("replace", k, v));