@spearwolf/shadow-objects 0.33.0 → 0.34.0

package/src/in-the-dark/Entity.js

@@ -1,4 +1,4 @@
-import { emit, off, on, once, Priority } from "@spearwolf/eventize";
+import { emitStrict, off, on, once, Priority } from "@spearwolf/eventize";
 import {
   batch,
   createSignal,
@@ -7,24 +7,31 @@ import {
   SignalAutoMap,
   value
 } from "@spearwolf/signalize";
+import { MicrotaskCollector } from "../utils/MicrotaskCollector.js";
+import { runGuarded } from "../utils/runGuarded.js";
 import { onDestroy, onViewEvent } from "./events.js";
 import { Kernel } from "./Kernel.js";
 import { SignalsPath } from "./SignalsPath.js";
-const updateContextValues = /* @__PURE__ */ new Map();
-let requestedContextValueBatchUpdate = false;
-const deferContextValueUpdate = (sig, val) => {
-  updateContextValues.set(sig, val);
-  if (!requestedContextValueBatchUpdate) {
-    requestedContextValueBatchUpdate = true;
-    queueMicrotask(() => {
-      requestedContextValueBatchUpdate = false;
-      const contextValues = Array.from(updateContextValues.entries());
-      updateContextValues.clear();
-      for (const [sig2, val2] of contextValues) {
-        sig2.set(val2);
+const contextValueCollectors = /* @__PURE__ */ new WeakMap();
+const collectorOf = (kernel) => {
+  let collector = contextValueCollectors.get(kernel);
+  if (collector == null) {
+    collector = new MicrotaskCollector((contextValues) => {
+      for (const [contextSignal, entry] of contextValues) {
+        runGuarded(
+          kernel.logger,
+          () => contextSignal.set(entry.value),
+          `an effect of a context value failed (${String(entry.name)}):`,
+          entry.uuid
+        );
       }
     });
+    contextValueCollectors.set(kernel, collector);
   }
+  return collector;
+};
+const deferContextValueUpdate = (kernel, signal, val, name, uuid) => {
+  collectorOf(kernel).add(signal, { value: val, name, uuid });
 };
 class Entity {
   #kernel;
@@ -32,11 +39,14 @@ class Entity {
   #props = new SignalAutoMap();
   #context = /* @__PURE__ */ new Map();
   #rootContexts = /* @__PURE__ */ new Map();
-  #parentUuid;
+  // There is one place the parent is kept: `parentUuid` answers from `#parent.uuid`, so a half-set
+  // link -- a uuid with no matching entity, or an entity with no uuid to show for it -- has no field
+  // left to hold it in.
   #parent;
   #childrenUuids = /* @__PURE__ */ new Set();
   #children = [];
   #order = 0;
+  #isReleased = false;
   get kernel() {
     return this.#kernel;
   }
@@ -49,37 +59,40 @@ class Entity {
   set order(value2) {
     if (this.#order !== value2) {
       this.#order = value2;
-      if (this.#parentUuid) {
-        this.parent.resortChildren();
+      if (this.#parent) {
+        this.#parent.resortChildren();
       }
+      this.#kernel.noteEntityTreeChange(this.#uuid);
     }
   }
   get parentUuid() {
-    return this.#parentUuid || void 0;
+    return this.#parent?.uuid;
   }
   set parentUuid(parentUuid) {
-    if (this.#parentUuid !== parentUuid) {
+    if (this.#parent?.uuid !== parentUuid) {
       const nextParent = parentUuid ? this.#kernel.getEntity(parentUuid) : void 0;
-      this.removeFromParent();
-      this.#parentUuid = parentUuid || void 0;
+      if (nextParent != null) {
+        this.assertAttachableTo(nextParent);
+      }
+      this.#detachFromParent(nextParent == null);
       this.#parent = nextParent;
       if (this.#parent) {
         this.#parent.addChild(this);
       }
       this.#updateAutoDestructionSubscription();
+      this.#kernel.noteEntityTreeChange(this.#uuid);
     }
   }
   get parent() {
-    if (!this.#parent && this.#parentUuid) {
-      this.#parent = this.#kernel.getEntity(this.#parentUuid);
-    }
     return this.#parent;
   }
   set parent(parent) {
     this.parentUuid = parent?.uuid;
   }
+  // Reads the same field `parent` and `parentUuid` do, so `Kernel.noteEntityTreeChange()` -- which
+  // reads `hasParent` to decide whether the uuid belongs in the root set -- sees what they see.
   get hasParent() {
-    return !!this.#parentUuid;
+    return !!this.#parent;
   }
   get children() {
     return this.#children;
@@ -87,74 +100,166 @@ class Entity {
   constructor(kernel, uuid) {
     this.#kernel = kernel;
     this.#uuid = uuid;
-    once(this, onDestroy, Priority.Min, this);
   }
   traverse(callback) {
+    this.#traverse(callback, /* @__PURE__ */ new Set());
+  }
+  // The visited set guards the one traversal an outside shadow object drives, over a tree it did not
+  // build. `addChild()` writes a children list without touching the parent link, so no ancestor check
+  // can cover it.
+  #traverse(callback, visited) {
+    if (visited.has(this)) return;
+    visited.add(this);
     callback(this);
     for (const child of this.#children) {
-      child.traverse(callback);
+      child.#traverse(callback, visited);
     }
   }
+  /**
+   * Releases everything the entity holds: its properties, its subscriptions, its contexts and its place
+   * in the entity tree.
+   *
+   * It runs once, whichever way it is reached. The kernel reaches it directly, right behind the
+   * destruction notification it sends on the entity, so that every listener on that notification has
+   * had its turn first -- down to `Priority.Min`, which is nobody's but the caller's. The entity is
+   * not a listener on its own notification: registering it in the constructor would put it ahead of
+   * anything registered at the same priority, because eventize breaks a tie by order of registration,
+   * and the bulk `off(this)` below would then take the listeners still waiting in that delivery with
+   * it. The flag makes a second call cost nothing and keeps every step below written for a
+   * single run: `kernel.getEntity()` hands the entity to anyone, and this method is as reachable as
+   * the rest of it.
+   *
+   * The flag is raised before the first step rather than after the last, because that is what a release
+   * running twice would cost: the steps below are written for one pass, not for a repeat.
+   *
+   * Every step below runs behind a guard of its own, the way `ShadowObjectCreationScope.tearDown()`
+   * gives each of its steps one: a step that throws is reported through the kernel's logger, named by
+   * the step and by the uuid of this entity, and costs only itself -- the steps behind it still run.
+   * The method therefore never throws to its own caller. The plain resets at the end -- clearing a
+   * collection, overwriting a field -- cannot throw and run unguarded, exactly as `tearDown()` empties
+   * its own sets at the end.
+   */
   [onDestroy]() {
-    this.#props.clear();
-    off(this);
-    this.#autoDestructionSubscription?.();
+    if (this.#isReleased) return;
+    this.#isReleased = true;
+    this.#runGuarded("properties", () => this.#props.clear());
+    this.#runGuarded("listeners", () => off(this));
+    this.#runGuarded("auto-destruction subscription", () => this.#autoDestructionSubscription?.());
     for (const rootCtx of this.#rootContexts.values()) {
-      rootCtx.cleanup();
-      rootCtx.signal.destroy();
+      this.#runGuarded("global context cleanup", () => rootCtx.cleanup());
+      this.#runGuarded("global context signal", () => rootCtx.signal.destroy());
     }
-    this.#rootContexts.clear();
     for (const ctx of this.#context.values()) {
-      ctx.context.set(void 0);
-      ctx.unsubscribePathValue();
-      ctx.unsubscribeFromParent?.();
-      ctx.valuePath.dispose();
-      ctx.inherited.destroy();
-      ctx.provide.destroy();
-      ctx.context.destroy();
+      this.#runGuarded("context value reset", () => ctx.context.set(void 0));
+      this.#runGuarded("context value subscription", () => ctx.unsubscribePathValue());
+      this.#runGuarded("context parent subscription", () => ctx.unsubscribeFromParent?.());
+      this.#runGuarded("context value path", () => ctx.valuePath.dispose());
+      this.#runGuarded("inherited context signal", () => ctx.inherited.destroy());
+      this.#runGuarded("provided context signal", () => ctx.provide.destroy());
+      this.#runGuarded("context signal", () => ctx.context.destroy());
     }
-    this.#parentUuid = void 0;
+    this.#rootContexts.clear();
+    this.#context.clear();
     this.#parent = void 0;
     this.#childrenUuids.clear();
     this.#children.length = 0;
   }
-  addChild(child) {
-    if (this.#children.length === 0) {
-      this.#childrenUuids.add(child.uuid);
-      this.#children.push(child);
-      return;
+  /**
+   * Isolates one release step from the ones around it: a step that throws is reported through the
+   * kernel's logger and does not stop `[onDestroy]()` from reaching the steps that follow. The
+   * report goes out through the shared `runGuarded()`; what this wrapper adds is the label of the
+   * step and the uuid of the entity it belongs to.
+   */
+  #runGuarded(step, run) {
+    runGuarded(this.#kernel.logger, run, `entity teardown step failed (${step}):`, this.#uuid);
+  }
+  /**
+   * Refuses a parent that would close the entity tree into a ring: the entity itself, or an entity that
+   * already sits below it. The walk follows the parent chain upwards, which is a chain exactly because
+   * this guard keeps it one.
+   *
+   * `Kernel.setParent()` calls it before it detaches, and the `parentUuid` setter before it resolves the
+   * link, so a refused attachment leaves the entity where it was instead of orphaned halfway through.
+   * `ViewComponent.addChild()` guards the same thing on the view side.
+   */
+  assertAttachableTo(nextParent) {
+    for (let e = nextParent; e != null; e = e.parent) {
+      if (e === this) {
+        throw new Error(
+          `entity "${nextParent.uuid}" cannot become the parent of "${this.uuid}": it is the entity itself or one of its descendants`
+        );
+      }
     }
+  }
+  /**
+   * Puts `child` into the children list, at its place among the siblings.
+   *
+   * Nothing here notifies. Neither this method nor {@link Entity.removeChild} nor a detachment
+   * sends anything to a listener on the entity -- the one notification over a moved entity is
+   * `onParentChanged`, and `Kernel.setParent()` is the call that sends it.
+   */
+  addChild(child) {
     if (this.#childrenUuids.has(child.uuid)) {
       throw new Error(`child with uuid: ${child.uuid} already exists! parentUuid: ${this.uuid}`);
     }
     this.#childrenUuids.add(child.uuid);
-    this.#children.push(child);
-    this.resortChildren();
+    this.#insertChildInOrder(child);
     for (const [, ctx] of child.#context) {
       child.#subscribeToParent(ctx);
     }
   }
+  /**
+   * Puts a child at its place among the siblings, so building a subtree costs one insertion per
+   * child. The scan runs from the end because children usually arrive with an equal or rising
+   * `order`, which makes the common case a plain append. A child lands behind every sibling that
+   * shares its `order` -- the same place a stable sort would give it.
+   *
+   * The result only matches a full sort while `#children` is already sorted when the insertion
+   * starts, so name what keeps it that way: the insertion here preserves the order, `removeChild()`
+   * cuts an element out with `splice`, the destroy handler empties the list, and the `order` setter
+   * re-sorts through the parent. That last one is the condition worth stating, because it needs the
+   * child to know its parent -- the parent link has to be established. Every way an entity is
+   * attached inside this class goes through the `parentUuid` setter, which sets the parent before it
+   * calls `addChild()`. A caller that reaches for `addChild()` on its own leaves the child without a
+   * parent link, and a later `order` on such a child never reaches this list.
+   */
+  #insertChildInOrder(child) {
+    let i = this.#children.length;
+    while (i > 0 && child.order < this.#children[i - 1].order) i--;
+    this.#children.splice(i, 0, child);
+  }
   resortChildren() {
     this.#children.sort((a, b) => a.order - b.order);
   }
   removeChild(child) {
-    if (this.#childrenUuids.has(child.uuid)) {
+    const idx = this.#children.indexOf(child);
+    if (idx !== -1) {
       this.#childrenUuids.delete(child.uuid);
-      this.#children.splice(this.#children.indexOf(child), 1);
+      this.#children.splice(idx, 1);
     }
   }
-  removeFromParent() {
+  /**
+   * @param rebindContexts bind every context back to the root of the entity context tree. An entity
+   *   that carries a context out of a subtree keeps following the value it can still see, rather
+   *   than freezing on the last one the former parent held. Only a caller that attaches the entity
+   *   to the next parent in the same breath passes `false` -- that parent binds the contexts itself,
+   *   and the detour over the root would be visible to `useParentContext()`, which hands out the
+   *   inherited value without the microtask collector `useContext()` has in front of it.
+   */
+  removeFromParent(rebindContexts = true) {
+    this.#detachFromParent(rebindContexts);
+  }
+  #detachFromParent(rebindContexts) {
     if (this.#parent) {
       this.#parent.removeChild(this);
       this.#parent = void 0;
-      this.#parentUuid = void 0;
-      for (const [, ctx] of this.#context) {
-        if (ctx.unsubscribeFromParent) {
-          ctx.unsubscribeFromParent();
-          ctx.unsubscribeFromParent = void 0;
+      if (rebindContexts) {
+        for (const [, ctx] of this.#context) {
+          this.#subscribeToParent(ctx);
         }
       }
       this.#unsubscribeAutoDestruction();
+      this.#kernel.noteEntityTreeChange(this.#uuid);
     }
   }
   #autoDestructionEnabled = false;
@@ -182,6 +287,15 @@ class Entity {
       });
     }
   }
+  /**
+   * Binds every context of this entity to its current position in the entity tree -- to the parent
+   * if there is one, to the root otherwise. `addChild()` and `removeFromParent()` each do this for
+   * the entity they move, so a caller needs this only when it changed the position by other means
+   * or wants the binding re-established without knowing which of the two ran.
+   *
+   * Moving an entity through the kernel is not such a case: both directions bring their own binding,
+   * and a third one would reach every `useParentContext()` reader as another change.
+   */
   reSubscribeToParentContexts() {
     for (const [, ctx] of this.#context) {
       this.#subscribeToParent(ctx);
@@ -190,9 +304,28 @@ class Entity {
   dispatchMessageToView(type, data, transferables, traverseChildren = false) {
     this.#kernel.dispatchMessageToView({ uuid: this.#uuid, type, data, transferables, traverseChildren });
   }
+  /**
+   * Hands the events the view sent to whoever listens on this entity, one delivery per event.
+   *
+   * Each delivery is guarded, and the reason is where this call sits: the kernel makes it from
+   * inside a change trail, on a path that builds. Unguarded, a single shadow-object that cannot cope
+   * with a single view event would leave through `Kernel.run()` and refuse the whole trail -- the
+   * same argument that puts a guard around the `onParentChanged` notification, which is a delivery
+   * on a building path as well. The guard is per event, so one that fails costs neither the events
+   * behind it nor the caller anything; `emitStrict()` inside it makes the same promise one level
+   * down, to the listeners of one event.
+   */
   dispatchViewEvents(events) {
     for (const { type, data } of events) {
-      emit(this, onViewEvent, type, data);
+      runGuarded(
+        this.#kernel.logger,
+        // the concrete class is needed here: eventize cannot reduce its emitter conditional
+        // (`NonTypedEmitter<this>`) over the polymorphic `this` type, and no overload then matches
+        () => emitStrict(this, onViewEvent, type, data),
+        "entity view event delivery failed:",
+        type,
+        this.#uuid
+      );
     }
   }
   dispatchViewEvent(type, data) {
@@ -204,11 +337,30 @@ class Entity {
   getPropertyReader(key) {
     return this.#getPropSignal(key).get;
   }
+  /**
+   * A write head for one property. Every write through it drops the cache behind
+   * `truthyProps()`: that cache answers `Kernel.#updateShadowObjects()`, which picks the shadow
+   * objects of this entity along the property routes of the registry, and a write the cache does
+   * not see routes the entity to a state it no longer has.
+   *
+   * What comes back is a function of the entity, not the `set` of the signal behind the property.
+   * The signalize helpers that take a signal-like -- `isSignal()`, `destroySignal()`, `touch()` --
+   * do not recognise it; `getPropertyReader()` hands out the signal's own reader for that.
+   *
+   * A fresh closure is handed out on every call rather than one cached per key: `SignalAutoMap`
+   * hands out "a fresh, live" signal for a key whose signal was destroyed from the outside, so a
+   * writer cached against the signal captured on an earlier call could end up closing over a corpse.
+   * The call sites this feeds -- `setProperty()` from a change-trail application, at most once per
+   * property that actually changed -- do not turn this into a hot path.
+   */
   getPropertyWriter(key) {
-    return this.#getPropSignal(key).set;
+    const signal = this.#getPropSignal(key);
+    return (value2, params) => {
+      this.clearTruthyPropsCache();
+      signal.set(value2, params);
+    };
   }
   setProperties(properties) {
-    this.clearTruthyPropsCache();
     batch(() => {
       for (const [key, val] of properties) {
         this.setProperty(key, val);
@@ -260,14 +412,91 @@ class Entity {
     return this.#findOrCreateContext(name).provide;
   }
   provideGlobalContext(name) {
+    return this.#findOrCreateGlobalContext(name).signal;
+  }
+  /**
+   * Attaches a provider signal to the context of `name` on this entity and answers with the release
+   * that detaches it again.
+   *
+   * Every provider of one name writes into the single signal that `provideContext()` hands out, so
+   * what a consumer reads is what was written last. The release therefore does two things: it cuts
+   * this feed, and it then lets a provider that is still attached write its value once more. Without
+   * that second step the context would keep whatever the departure left standing -- the `undefined`
+   * of a clearing provider, or the last value of one that opted out of it -- even though this entity
+   * still has a provider of the name that says otherwise.
+   *
+   * A value written straight into the signal from `provideContext()` is not a feed and is therefore
+   * overwritten by the next release. Feeding a value in through this method is what makes it survive
+   * one.
+   */
+  attachContextProvider(name, provider) {
+    const ctx = this.#findOrCreateContext(name);
+    return Entity.#attachProviderFeed(provider, ctx.provide, ctx.providerFeeds);
+  }
+  /**
+   * The counterpart of {@link Entity.attachContextProvider} for the global context of `name`.
+   *
+   * Within one entity the situation is the same one: every provider feeds the single signal this
+   * entity contributes to the kernel-wide chain of that name, and a release hands the name back to a
+   * provider that stays. Across entities the chain decides on its own -- it resolves to the first
+   * entry that holds something, so an entity whose signal falls empty lets the next one through.
+   */
+  attachGlobalContextProvider(name, provider) {
+    const rootCtx = this.#findOrCreateGlobalContext(name);
+    return Entity.#attachProviderFeed(provider, rootCtx.signal, rootCtx.providerFeeds);
+  }
+  static #attachProviderFeed(provider, target, feeds) {
+    const feed = link(provider, target);
+    feeds.add(feed);
+    return () => {
+      if (!feeds.delete(feed)) return;
+      feed.destroy();
+      Entity.#handOverToRemainingProvider(feeds);
+    };
+  }
+  /**
+   * Lets the provider that stays write its value into the context signal again.
+   *
+   * The set iterates in the order the providers were attached and the loop keeps the last hit, so the
+   * winner is the one attached last that still holds a value. Attachment order is the order in which the
+   * providers took the name: attaching feeds the value straight through, so a later attachment writes
+   * over an earlier one, and the hand-over falls back on that order instead of inventing one of its own.
+   * It is not the order of the writes -- a provider that writes to its signal after attaching carries
+   * the name until the next departure, and the hand-over does not restore that write, because what this
+   * entity keeps on file is its providers and not the sequence in which they wrote. Providers holding
+   * nothing are passed over -- by the same `!= null` rule with which `SignalsPath` resolves a context
+   * chain, and for the same reason: a provider without a value has nothing to say about the name, and
+   * electing it would clear a name that is still being provided.
+   *
+   * A feed whose link is destroyed is passed over as well. A shadow-object owns the signal it was
+   * handed and may end it early, which destroys the link without the release ever having run: such a
+   * feed still reports a value through its source while its writes go nowhere, so electing it would
+   * leave the write of the departure standing, silently and over a provider that is alive.
+   *
+   * `touch()` is what makes the winner write, because `SignalLink.write()` is protected: touching is
+   * the only public way to push the current value of a source through its link again, and the source
+   * of a provider that merely stays has no reason to change.
+   *
+   * Where no remaining feed qualifies, nothing is written: then what the departure left stands,
+   * which is the `undefined` of a clearing provider or the last value of one that opted out.
+   */
+  static #handOverToRemainingProvider(feeds) {
+    let winner;
+    for (const feed of feeds) {
+      if (!feed.isDestroyed && feed.source.value != null) winner = feed;
+    }
+    winner?.touch();
+  }
+  #findOrCreateGlobalContext(name) {
     if (this.#rootContexts.has(name)) {
-      return this.#rootContexts.get(name).signal;
+      return this.#rootContexts.get(name);
     }
     const rootCtx = this.#kernel.findOrCreateRootContext(name);
     const signal = createSignal();
     const cleanup = rootCtx.add(signal);
-    this.#rootContexts.set(name, { cleanup, signal });
-    return signal;
+    const ctx = { cleanup, signal, providerFeeds: /* @__PURE__ */ new Set() };
+    this.#rootContexts.set(name, ctx);
+    return ctx;
   }
   #findOrCreateContext(name) {
     if (this.#context.has(name)) {
@@ -278,9 +507,9 @@ class Entity {
     const context = createSignal();
     const valuePath = new SignalsPath([provide, inherited]);
     const unsubscribePathValue = on(valuePath, SignalsPath.Value, (val) => {
-      deferContextValueUpdate(context, val);
+      deferContextValueUpdate(this.#kernel, context, val, name, this.#uuid);
     });
-    const ctx = { name, inherited, provide, context, valuePath, unsubscribePathValue };
+    const ctx = { name, inherited, provide, context, valuePath, providerFeeds: /* @__PURE__ */ new Set(), unsubscribePathValue };
     this.#context.set(name, ctx);
     this.#subscribeToParent(ctx);
     return ctx;

package/src/in-the-dark/Entity.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/in-the-dark/Entity.ts"],
-  "sourcesContent": ["import {emit, off, on, once, Priority} from '@spearwolf/eventize';\nimport {\n  batch,\n  createSignal,\n  link,\n  Signal,\n  SignalAutoMap,\n  type SignalReader,\n  type SignalWriter,\n  value,\n} from '@spearwolf/signalize';\nimport type {IComponentEvent} from '../types.js';\nimport {onDestroy, onViewEvent} from './events.js';\nimport {Kernel} from './Kernel.js';\nimport {SignalsPath} from './SignalsPath.js';\n\ntype ContextNameType = string | symbol;\n\ninterface IContextValue {\n  name: ContextNameType;\n  inherited: Signal<unknown>;\n  provide: Signal<unknown>;\n  context: Signal<unknown>;\n  valuePath: SignalsPath;\n\n  unsubscribePathValue: () => void;\n  unsubscribeFromParent?: () => void;\n}\n\nconst updateContextValues: Map<Signal<unknown>, unknown> = new Map();\nlet requestedContextValueBatchUpdate = false;\n\nconst deferContextValueUpdate = (sig: Signal<unknown>, val: unknown) => {\n  updateContextValues.set(sig, val);\n  if (!requestedContextValueBatchUpdate) {\n    requestedContextValueBatchUpdate = true;\n    queueMicrotask(() => {\n      requestedContextValueBatchUpdate = false;\n      const contextValues = Array.from(updateContextValues.entries());\n      updateContextValues.clear();\n      for (const [sig, val] of contextValues) {\n        sig.set(val);\n      }\n    });\n  }\n};\n\n/**\n * An entity has a parent and children, replicating the hierarchy of view-components.\n *\n * A signal is created for each view-component property.\n *\n * Shadow-objects can use the signal properties via the entity.\n */\nexport class Entity {\n  #kernel: Kernel;\n  #uuid: string;\n\n  #props = new SignalAutoMap();\n  #context: Map<ContextNameType, IContextValue> = new Map();\n\n  #rootContexts: Map<ContextNameType, {cleanup: () => void; signal: Signal<any>}> = new Map();\n\n  #parentUuid?: string;\n  #parent?: Entity;\n\n  #childrenUuids: Set<string> = new Set();\n  #children: Entity[] = [];\n\n  #order = 0;\n\n  get kernel(): Kernel {\n    return this.#kernel;\n  }\n\n  get uuid(): string {\n    return this.#uuid;\n  }\n\n  get order(): number {\n    return this.#order;\n  }\n\n  set order(value: number) {\n    if (this.#order !== value) {\n      this.#order = value;\n      if (this.#parentUuid) {\n        this.parent!.resortChildren();\n      }\n    }\n  }\n\n  get parentUuid(): string | undefined {\n    return this.#parentUuid || undefined;\n  }\n\n  set parentUuid(parentUuid: string | undefined) {\n    if (this.#parentUuid !== parentUuid) {\n      // Resolve the new parent FIRST so an unknown-uuid throw doesn't orphan us mid-mutation.\n      const nextParent = parentUuid ? this.#kernel.getEntity(parentUuid) : undefined;\n\n      this.removeFromParent();\n\n      this.#parentUuid = parentUuid || undefined;\n      this.#parent = nextParent;\n\n      if (this.#parent) {\n        this.#parent.addChild(this);\n      }\n\n      this.#updateAutoDestructionSubscription();\n    }\n  }\n\n  get parent(): Entity | undefined {\n    if (!this.#parent && this.#parentUuid) {\n      this.#parent = this.#kernel.getEntity(this.#parentUuid);\n    }\n    return this.#parent;\n  }\n\n  set parent(parent: Entity | undefined) {\n    this.parentUuid = parent?.uuid;\n  }\n\n  get hasParent(): boolean {\n    return !!this.#parentUuid;\n  }\n\n  get children(): readonly Entity[] {\n    return this.#children;\n  }\n\n  constructor(kernel: Kernel, uuid: string) {\n    this.#kernel = kernel;\n    this.#uuid = uuid;\n    once(this as Entity, onDestroy, Priority.Min, this);\n  }\n\n  traverse(callback: (entity: Entity) => void) {\n    callback(this);\n    for (const child of this.#children) {\n      child.traverse(callback);\n    }\n  }\n\n  [onDestroy]() {\n    this.#props.clear();\n    off(this);\n\n    this.#autoDestructionSubscription?.();\n\n    for (const rootCtx of this.#rootContexts.values()) {\n      rootCtx.cleanup();\n      rootCtx.signal.destroy();\n    }\n    this.#rootContexts.clear();\n\n    for (const ctx of this.#context.values()) {\n      ctx.context.set(undefined);\n      ctx.unsubscribePathValue();\n      ctx.unsubscribeFromParent?.();\n      ctx.valuePath.dispose();\n      ctx.inherited.destroy();\n      ctx.provide.destroy();\n      ctx.context.destroy();\n    }\n\n    this.#parentUuid = undefined;\n    this.#parent = undefined;\n\n    this.#childrenUuids.clear();\n    this.#children.length = 0;\n  }\n\n  addChild(child: Entity) {\n    if (this.#children.length === 0) {\n      this.#childrenUuids.add(child.uuid);\n      this.#children.push(child);\n      // this.emit(onAddChild, this, child);\n      // child.emit(onAddToParent, child, this);\n      return;\n    }\n\n    if (this.#childrenUuids.has(child.uuid)) {\n      throw new Error(`child with uuid: ${child.uuid} already exists! parentUuid: ${this.uuid}`);\n    }\n\n    this.#childrenUuids.add(child.uuid);\n    this.#children.push(child);\n\n    this.resortChildren();\n\n    for (const [, ctx] of child.#context) {\n      child.#subscribeToParent(ctx);\n    }\n\n    // this.emit(onAddChild, this, child);\n    // child.emit(onAddToParent, child, this);\n  }\n\n  resortChildren() {\n    this.#children.sort((a, b) => a.order - b.order);\n  }\n\n  removeChild(child: Entity) {\n    if (this.#childrenUuids.has(child.uuid)) {\n      this.#childrenUuids.delete(child.uuid);\n      this.#children.splice(this.#children.indexOf(child), 1);\n      // this.emit(onRemoveChild, this, child);\n    }\n  }\n\n  removeFromParent() {\n    if (this.#parent) {\n      // const prevParent = this.#parent;\n\n      this.#parent.removeChild(this);\n\n      this.#parent = undefined;\n      this.#parentUuid = undefined;\n\n      for (const [, ctx] of this.#context) {\n        if (ctx.unsubscribeFromParent) {\n          ctx.unsubscribeFromParent();\n          ctx.unsubscribeFromParent = undefined;\n        }\n      }\n\n      this.#unsubscribeAutoDestruction();\n\n      // this.emit(onRemoveFromParent, this, prevParent);\n    }\n  }\n\n  #autoDestructionEnabled = false;\n  #autoDestructionSubscription?: () => void;\n\n  get autoDestructionOnParentRemoval(): boolean {\n    return this.#autoDestructionEnabled;\n  }\n\n  set autoDestructionOnParentRemoval(autoDestruct: boolean) {\n    if (this.#autoDestructionEnabled === autoDestruct) return;\n    this.#autoDestructionEnabled = autoDestruct;\n    this.#updateAutoDestructionSubscription();\n  }\n\n  #unsubscribeAutoDestruction() {\n    if (this.#autoDestructionSubscription) {\n      this.#autoDestructionSubscription();\n      this.#autoDestructionSubscription = undefined;\n    }\n  }\n\n  #updateAutoDestructionSubscription() {\n    this.#unsubscribeAutoDestruction();\n    if (this.#autoDestructionEnabled && this.#parent) {\n      this.#autoDestructionSubscription = once(this.#parent, onDestroy, Priority.Max, () => {\n        this.#autoDestructionSubscription = undefined;\n        this.#kernel.destroyEntity(this.#uuid);\n      });\n    }\n  }\n\n  reSubscribeToParentContexts() {\n    for (const [, ctx] of this.#context) {\n      this.#subscribeToParent(ctx);\n    }\n  }\n\n  dispatchMessageToView(type: string, data?: unknown, transferables?: Transferable[], traverseChildren = false) {\n    this.#kernel.dispatchMessageToView({uuid: this.#uuid, type, data, transferables, traverseChildren});\n  }\n\n  dispatchViewEvents(events: IComponentEvent[]) {\n    for (const {type, data} of events) {\n      emit(this as Entity, onViewEvent, type, data);\n    }\n  }\n\n  dispatchViewEvent(type: string, data: unknown) {\n    this.dispatchViewEvents([{type, data}]);\n  }\n\n  #getPropSignal<T = unknown>(key: string): Signal<T> {\n    return this.#props.get<T>(key);\n  }\n\n  getPropertyReader<T = unknown>(key: string): SignalReader<T> {\n    return this.#getPropSignal<T>(key).get;\n  }\n\n  getPropertyWriter<T = unknown>(key: string): SignalWriter<T> {\n    return this.#getPropSignal<T>(key).set;\n  }\n\n  setProperties(properties: [string, unknown][]) {\n    this.clearTruthyPropsCache();\n    batch(() => {\n      for (const [key, val] of properties) {\n        this.setProperty(key, val);\n      }\n    });\n  }\n\n  setProperty(key: string, value: unknown) {\n    this.getPropertyWriter(key)(value);\n  }\n\n  getProperty<T = unknown>(key: string): T {\n    return value(this.getPropertyReader<T>(key));\n  }\n\n  propKeys(): string[] {\n    return Array.from(this.#props.keys()) as string[];\n  }\n\n  propEntries(): [string, unknown][] {\n    return Array.from(this.#props.entries()).map(([key, sig]) => [key, sig.value]) as [string, unknown][];\n  }\n\n  #truthyPropsCache: Set<string> | undefined;\n\n  clearTruthyPropsCache() {\n    this.#truthyPropsCache = undefined;\n  }\n\n  truthyProps(): Set<string> | undefined {\n    if (this.#truthyPropsCache) {\n      return this.#truthyPropsCache.size ? this.#truthyPropsCache : undefined;\n    }\n    const truthyProps = new Set<string>();\n    for (const [key, sig] of this.#props.entries()) {\n      if (typeof key === 'string') {\n        const val = sig.value;\n        if (val != null && val !== false && val !== '') {\n          truthyProps.add(key);\n        }\n      }\n    }\n    this.#truthyPropsCache = truthyProps;\n    return truthyProps.size ? truthyProps : undefined;\n  }\n\n  hasContext(name: ContextNameType): boolean {\n    return this.#context.has(name);\n  }\n\n  useContext<T = unknown>(name: ContextNameType): SignalReader<T> {\n    return this.#findOrCreateContext(name).context.get as SignalReader<T>;\n  }\n\n  useParentContext<T = unknown>(name: ContextNameType): SignalReader<T> {\n    return this.#findOrCreateContext(name).inherited.get as SignalReader<T>;\n  }\n\n  provideContext<T = unknown>(name: ContextNameType): Signal<T> {\n    return this.#findOrCreateContext(name).provide as Signal<T>;\n  }\n\n  provideGlobalContext<T = unknown>(name: ContextNameType): Signal<T> {\n    if (this.#rootContexts.has(name)) {\n      return this.#rootContexts.get(name)!.signal as Signal<T>;\n    }\n    const rootCtx = this.#kernel.findOrCreateRootContext(name);\n    const signal = createSignal<T>();\n    const cleanup = rootCtx.add(signal);\n    this.#rootContexts.set(name, {cleanup, signal});\n    return signal;\n  }\n\n  #findOrCreateContext(name: ContextNameType): IContextValue {\n    if (this.#context.has(name)) {\n      return this.#context.get(name)!;\n    }\n\n    const inherited = createSignal();\n    const provide = createSignal();\n    const context = createSignal();\n\n    const valuePath = new SignalsPath([provide, inherited]);\n\n    const unsubscribePathValue = on(valuePath, SignalsPath.Value, (val) => {\n      deferContextValueUpdate(context, val);\n    });\n\n    const ctx: IContextValue = {name, inherited, provide, context, valuePath, unsubscribePathValue};\n    this.#context.set(name, ctx);\n\n    this.#subscribeToParent(ctx);\n\n    return ctx;\n  }\n\n  #subscribeToParent(ctx: IContextValue) {\n    ctx.unsubscribeFromParent?.();\n    ctx.unsubscribeFromParent = undefined;\n    if (this.parent) {\n      const parentCtx = this.parent.#findOrCreateContext(ctx.name);\n      const linkToParent = link(parentCtx.context, ctx.inherited);\n      ctx.unsubscribeFromParent = linkToParent.destroy.bind(linkToParent);\n    } else {\n      const rootCtx = this.#kernel.findOrCreateRootContext(ctx.name);\n      const linkToRoot = link(rootCtx.value$, ctx.inherited);\n      ctx.unsubscribeFromParent = linkToRoot.destroy.bind(linkToRoot);\n    }\n  }\n}"],
-  "mappings": "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",
-  "names": ["sig", "val", "value"]
+  "sourcesContent": ["import {emitStrict, off, on, once, Priority} from '@spearwolf/eventize';\nimport {\n  batch,\n  createSignal,\n  link,\n  Signal,\n  SignalAutoMap,\n  type SignalLink,\n  type SignalReader,\n  type SignalWriter,\n  type SignalWriterParams,\n  value,\n} from '@spearwolf/signalize';\nimport type {ComponentPropertiesType, IComponentEvent} from '../types.js';\nimport {MicrotaskCollector} from '../utils/MicrotaskCollector.js';\nimport {runGuarded} from '../utils/runGuarded.js';\nimport {onDestroy, onViewEvent} from './events.js';\nimport {Kernel} from './Kernel.js';\nimport {SignalsPath} from './SignalsPath.js';\n\ntype ContextNameType = string | symbol;\n\ninterface IContextValue {\n  name: ContextNameType;\n  inherited: Signal<unknown>;\n  provide: Signal<unknown>;\n  context: Signal<unknown>;\n  valuePath: SignalsPath;\n\n  /**\n   * The links that feed `provide`, one per provider of this name on this entity. They all write\n   * into that one signal, so the value standing there is the one written last -- and the set is\n   * what makes it possible to ask a provider that is still here for its value once another one\n   * lets go. See {@link Entity.attachContextProvider}.\n   */\n  providerFeeds: Set<SignalLink<any>>;\n\n  unsubscribePathValue: () => void;\n  unsubscribeFromParent?: (() => void) | undefined;\n}\n\ninterface IRootContextValue {\n  signal: Signal<any>;\n\n  /** The links that feed `signal`, exactly as {@link IContextValue.providerFeeds} feeds `provide`. */\n  providerFeeds: Set<SignalLink<any>>;\n\n  /** Takes the entity's signal back out of the kernel-wide chain of this name. */\n  cleanup: () => void;\n}\n\n/** One context value an entity has waiting for its readers in the current round. */\ninterface IDeferredContextValue {\n  value: unknown;\n  name: ContextNameType;\n  uuid: string;\n}\n\n/**\n * The context values waiting to reach their readers, one collector per kernel.\n *\n * Per kernel rather than per module for two reasons that are the same one: a write below can fail,\n * and what it is reported to is a logger, of which there is one per kernel; and an application\n * running two shadow environments in one realm would otherwise hand the values of one to a round\n * the other started. The kernel is the key, so a collector reaches no further than the kernel it\n * belongs to and needs no teardown of its own -- every round empties it, and the last one is\n * emptied by the kernel going out of reach.\n */\nconst contextValueCollectors = new WeakMap<Kernel, MicrotaskCollector<Signal<unknown>, IDeferredContextValue>>();\n\nconst collectorOf = (kernel: Kernel): MicrotaskCollector<Signal<unknown>, IDeferredContextValue> => {\n  let collector = contextValueCollectors.get(kernel);\n  if (collector == null) {\n    collector = new MicrotaskCollector<Signal<unknown>, IDeferredContextValue>((contextValues) => {\n      for (const [contextSignal, entry] of contextValues) {\n        // one hand-over is one context value: `set()` runs the effects that read it synchronously\n        // and throws what one of them threw\n        runGuarded(\n          kernel.logger,\n          () => contextSignal.set(entry.value),\n          `an effect of a context value failed (${String(entry.name)}):`,\n          entry.uuid,\n        );\n      }\n    });\n    contextValueCollectors.set(kernel, collector);\n  }\n  return collector;\n};\n\n/**\n * Collects the context values written in one task and hands them to their readers a microtask\n * later, one at a time. A second value for the same signal replaces the one waiting, so a name\n * written twice in a task reaches its readers once, with the value that stood at the end of it.\n */\nconst deferContextValueUpdate = (kernel: Kernel, signal: Signal<unknown>, val: unknown, name: ContextNameType, uuid: string) => {\n  collectorOf(kernel).add(signal, {value: val, name, uuid});\n};\n\n/**\n * An entity has a parent and children, replicating the hierarchy of view-components.\n *\n * A signal is created for each view-component property.\n *\n * Shadow-objects can use the signal properties via the entity.\n */\nexport class Entity {\n  #kernel: Kernel;\n  #uuid: string;\n\n  #props = new SignalAutoMap();\n  #context: Map<ContextNameType, IContextValue> = new Map();\n\n  #rootContexts: Map<ContextNameType, IRootContextValue> = new Map();\n\n  // There is one place the parent is kept: `parentUuid` answers from `#parent.uuid`, so a half-set\n  // link -- a uuid with no matching entity, or an entity with no uuid to show for it -- has no field\n  // left to hold it in.\n  #parent?: Entity | undefined;\n\n  #childrenUuids: Set<string> = new Set();\n  #children: Entity[] = [];\n\n  #order = 0;\n\n  #isReleased = false;\n\n  get kernel(): Kernel {\n    return this.#kernel;\n  }\n\n  get uuid(): string {\n    return this.#uuid;\n  }\n\n  get order(): number {\n    return this.#order;\n  }\n\n  set order(value: number) {\n    if (this.#order !== value) {\n      this.#order = value;\n      if (this.#parent) {\n        this.#parent.resortChildren();\n      }\n      // The place among the siblings is part of the traversal order the kernel caches.\n      this.#kernel.noteEntityTreeChange(this.#uuid);\n    }\n  }\n\n  get parentUuid(): string | undefined {\n    return this.#parent?.uuid;\n  }\n\n  set parentUuid(parentUuid: string | undefined) {\n    if (this.#parent?.uuid !== parentUuid) {\n      // Resolve the new parent FIRST so an unknown-uuid throw doesn't orphan us mid-mutation.\n      const nextParent = parentUuid ? this.#kernel.getEntity(parentUuid) : undefined;\n\n      if (nextParent != null) {\n        this.assertAttachableTo(nextParent);\n      }\n\n      // A parent that follows right away binds the contexts itself, so the detachment skips it. The\n      // entity keeps reading the parent it leaves until the one it joins takes over.\n      this.#detachFromParent(nextParent == null);\n\n      this.#parent = nextParent;\n\n      if (this.#parent) {\n        this.#parent.addChild(this);\n      }\n\n      this.#updateAutoDestructionSubscription();\n\n      // The link is written; the kernel writes down where the entity stands now. This is the route\n      // a shadow-object takes when it moves an entity without going through `Kernel.setParent()`,\n      // and the report is the only thing the two share -- the `onParentChanged` notification stays\n      // with `setParent()`.\n      this.#kernel.noteEntityTreeChange(this.#uuid);\n    }\n  }\n\n  get parent(): Entity | undefined {\n    return this.#parent;\n  }\n\n  set parent(parent: Entity | undefined) {\n    this.parentUuid = parent?.uuid;\n  }\n\n  // Reads the same field `parent` and `parentUuid` do, so `Kernel.noteEntityTreeChange()` -- which\n  // reads `hasParent` to decide whether the uuid belongs in the root set -- sees what they see.\n  get hasParent(): boolean {\n    return !!this.#parent;\n  }\n\n  get children(): readonly Entity[] {\n    return this.#children;\n  }\n\n  constructor(kernel: Kernel, uuid: string) {\n    this.#kernel = kernel;\n    this.#uuid = uuid;\n  }\n\n  traverse(callback: (entity: Entity) => void) {\n    this.#traverse(callback, new Set());\n  }\n\n  // The visited set guards the one traversal an outside shadow object drives, over a tree it did not\n  // build. `addChild()` writes a children list without touching the parent link, so no ancestor check\n  // can cover it.\n  #traverse(callback: (entity: Entity) => void, visited: Set<Entity>) {\n    if (visited.has(this)) return;\n    visited.add(this);\n\n    callback(this);\n\n    for (const child of this.#children) {\n      child.#traverse(callback, visited);\n    }\n  }\n\n  /**\n   * Releases everything the entity holds: its properties, its subscriptions, its contexts and its place\n   * in the entity tree.\n   *\n   * It runs once, whichever way it is reached. The kernel reaches it directly, right behind the\n   * destruction notification it sends on the entity, so that every listener on that notification has\n   * had its turn first -- down to `Priority.Min`, which is nobody's but the caller's. The entity is\n   * not a listener on its own notification: registering it in the constructor would put it ahead of\n   * anything registered at the same priority, because eventize breaks a tie by order of registration,\n   * and the bulk `off(this)` below would then take the listeners still waiting in that delivery with\n   * it. The flag makes a second call cost nothing and keeps every step below written for a\n   * single run: `kernel.getEntity()` hands the entity to anyone, and this method is as reachable as\n   * the rest of it.\n   *\n   * The flag is raised before the first step rather than after the last, because that is what a release\n   * running twice would cost: the steps below are written for one pass, not for a repeat.\n   *\n   * Every step below runs behind a guard of its own, the way `ShadowObjectCreationScope.tearDown()`\n   * gives each of its steps one: a step that throws is reported through the kernel's logger, named by\n   * the step and by the uuid of this entity, and costs only itself -- the steps behind it still run.\n   * The method therefore never throws to its own caller. The plain resets at the end -- clearing a\n   * collection, overwriting a field -- cannot throw and run unguarded, exactly as `tearDown()` empties\n   * its own sets at the end.\n   */\n  [onDestroy]() {\n    if (this.#isReleased) return;\n    this.#isReleased = true;\n\n    // `SignalAutoMap.clear()` destroys every property signal and only then re-raises whatever a\n    // dependent effect's cleanup threw along the way, so it belongs behind a guard of its own like\n    // every other step here -- it is not the plain reset it looks like.\n    this.#runGuarded('properties', () => this.#props.clear());\n    this.#runGuarded('listeners', () => off(this));\n    this.#runGuarded('auto-destruction subscription', () => this.#autoDestructionSubscription?.());\n\n    for (const rootCtx of this.#rootContexts.values()) {\n      this.#runGuarded('global context cleanup', () => rootCtx.cleanup());\n      this.#runGuarded('global context signal', () => rootCtx.signal.destroy());\n    }\n\n    for (const ctx of this.#context.values()) {\n      this.#runGuarded('context value reset', () => ctx.context.set(undefined));\n      this.#runGuarded('context value subscription', () => ctx.unsubscribePathValue());\n      this.#runGuarded('context parent subscription', () => ctx.unsubscribeFromParent?.());\n      this.#runGuarded('context value path', () => ctx.valuePath.dispose());\n      this.#runGuarded('inherited context signal', () => ctx.inherited.destroy());\n      this.#runGuarded('provided context signal', () => ctx.provide.destroy());\n      this.#runGuarded('context signal', () => ctx.context.destroy());\n    }\n\n    this.#rootContexts.clear();\n    this.#context.clear();\n\n    this.#parent = undefined;\n\n    this.#childrenUuids.clear();\n    this.#children.length = 0;\n  }\n\n  /**\n   * Isolates one release step from the ones around it: a step that throws is reported through the\n   * kernel's logger and does not stop `[onDestroy]()` from reaching the steps that follow. The\n   * report goes out through the shared `runGuarded()`; what this wrapper adds is the label of the\n   * step and the uuid of the entity it belongs to.\n   */\n  #runGuarded(step: string, run: () => void): void {\n    runGuarded(this.#kernel.logger, run, `entity teardown step failed (${step}):`, this.#uuid);\n  }\n\n  /**\n   * Refuses a parent that would close the entity tree into a ring: the entity itself, or an entity that\n   * already sits below it. The walk follows the parent chain upwards, which is a chain exactly because\n   * this guard keeps it one.\n   *\n   * `Kernel.setParent()` calls it before it detaches, and the `parentUuid` setter before it resolves the\n   * link, so a refused attachment leaves the entity where it was instead of orphaned halfway through.\n   * `ViewComponent.addChild()` guards the same thing on the view side.\n   */\n  assertAttachableTo(nextParent: Entity) {\n    for (let e: Entity | undefined = nextParent; e != null; e = e.parent) {\n      if (e === this) {\n        throw new Error(\n          `entity \"${nextParent.uuid}\" cannot become the parent of \"${this.uuid}\": it is the entity itself or one of its descendants`,\n        );\n      }\n    }\n  }\n\n  /**\n   * Puts `child` into the children list, at its place among the siblings.\n   *\n   * Nothing here notifies. Neither this method nor {@link Entity.removeChild} nor a detachment\n   * sends anything to a listener on the entity -- the one notification over a moved entity is\n   * `onParentChanged`, and `Kernel.setParent()` is the call that sends it.\n   */\n  addChild(child: Entity) {\n    if (this.#childrenUuids.has(child.uuid)) {\n      throw new Error(`child with uuid: ${child.uuid} already exists! parentUuid: ${this.uuid}`);\n    }\n\n    this.#childrenUuids.add(child.uuid);\n    this.#insertChildInOrder(child);\n\n    // the child may have created its contexts while it was still unattached: they hang on the root\n    // of the entity context tree until something binds them to the parent they now have\n    for (const [, ctx] of child.#context) {\n      child.#subscribeToParent(ctx);\n    }\n  }\n\n  /**\n   * Puts a child at its place among the siblings, so building a subtree costs one insertion per\n   * child. The scan runs from the end because children usually arrive with an equal or rising\n   * `order`, which makes the common case a plain append. A child lands behind every sibling that\n   * shares its `order` -- the same place a stable sort would give it.\n   *\n   * The result only matches a full sort while `#children` is already sorted when the insertion\n   * starts, so name what keeps it that way: the insertion here preserves the order, `removeChild()`\n   * cuts an element out with `splice`, the destroy handler empties the list, and the `order` setter\n   * re-sorts through the parent. That last one is the condition worth stating, because it needs the\n   * child to know its parent -- the parent link has to be established. Every way an entity is\n   * attached inside this class goes through the `parentUuid` setter, which sets the parent before it\n   * calls `addChild()`. A caller that reaches for `addChild()` on its own leaves the child without a\n   * parent link, and a later `order` on such a child never reaches this list.\n   */\n  #insertChildInOrder(child: Entity) {\n    let i = this.#children.length;\n    while (i > 0 && child.order < this.#children[i - 1]!.order) i--;\n    this.#children.splice(i, 0, child);\n  }\n\n  resortChildren() {\n    this.#children.sort((a, b) => a.order - b.order);\n  }\n\n  removeChild(child: Entity) {\n    // The identity decides here, not the uuid: `indexOf` answers -1 for an entity this list\n    // does not hold, and a `splice(-1, 1)` on that answer would cut the last child out\n    // instead of none. The ordered uuid lists of `ComponentContext` carry the same guard where\n    // they cut a uuid out.\n    const idx = this.#children.indexOf(child);\n    if (idx !== -1) {\n      this.#childrenUuids.delete(child.uuid);\n      this.#children.splice(idx, 1);\n    }\n  }\n\n  /**\n   * @param rebindContexts bind every context back to the root of the entity context tree. An entity\n   *   that carries a context out of a subtree keeps following the value it can still see, rather\n   *   than freezing on the last one the former parent held. Only a caller that attaches the entity\n   *   to the next parent in the same breath passes `false` -- that parent binds the contexts itself,\n   *   and the detour over the root would be visible to `useParentContext()`, which hands out the\n   *   inherited value without the microtask collector `useContext()` has in front of it.\n   */\n  removeFromParent(rebindContexts = true) {\n    this.#detachFromParent(rebindContexts);\n  }\n\n  #detachFromParent(rebindContexts: boolean) {\n    // The field `parent` and `parentUuid` both answer from: clearing it here clears what either\n    // getter would report, with nothing left over for a second check to find.\n    if (this.#parent) {\n      this.#parent.removeChild(this);\n\n      this.#parent = undefined;\n\n      if (rebindContexts) {\n        for (const [, ctx] of this.#context) {\n          this.#subscribeToParent(ctx);\n        }\n      }\n\n      this.#unsubscribeAutoDestruction();\n\n      // Detached is a place too: an entity with no parent is a root, and the root set is where\n      // every traversal starts.\n      this.#kernel.noteEntityTreeChange(this.#uuid);\n    }\n  }\n\n  #autoDestructionEnabled = false;\n  #autoDestructionSubscription?: (() => void) | undefined;\n\n  get autoDestructionOnParentRemoval(): boolean {\n    return this.#autoDestructionEnabled;\n  }\n\n  set autoDestructionOnParentRemoval(autoDestruct: boolean) {\n    if (this.#autoDestructionEnabled === autoDestruct) return;\n    this.#autoDestructionEnabled = autoDestruct;\n    this.#updateAutoDestructionSubscription();\n  }\n\n  #unsubscribeAutoDestruction() {\n    if (this.#autoDestructionSubscription) {\n      this.#autoDestructionSubscription();\n      this.#autoDestructionSubscription = undefined;\n    }\n  }\n\n  #updateAutoDestructionSubscription() {\n    this.#unsubscribeAutoDestruction();\n    if (this.#autoDestructionEnabled && this.#parent) {\n      this.#autoDestructionSubscription = once(this.#parent, onDestroy, Priority.Max, () => {\n        this.#autoDestructionSubscription = undefined;\n        this.#kernel.destroyEntity(this.#uuid);\n      });\n    }\n  }\n\n  /**\n   * Binds every context of this entity to its current position in the entity tree -- to the parent\n   * if there is one, to the root otherwise. `addChild()` and `removeFromParent()` each do this for\n   * the entity they move, so a caller needs this only when it changed the position by other means\n   * or wants the binding re-established without knowing which of the two ran.\n   *\n   * Moving an entity through the kernel is not such a case: both directions bring their own binding,\n   * and a third one would reach every `useParentContext()` reader as another change.\n   */\n  reSubscribeToParentContexts() {\n    for (const [, ctx] of this.#context) {\n      this.#subscribeToParent(ctx);\n    }\n  }\n\n  dispatchMessageToView(type: string, data?: unknown, transferables?: Transferable[], traverseChildren = false) {\n    this.#kernel.dispatchMessageToView({uuid: this.#uuid, type, data, transferables, traverseChildren});\n  }\n\n  /**\n   * Hands the events the view sent to whoever listens on this entity, one delivery per event.\n   *\n   * Each delivery is guarded, and the reason is where this call sits: the kernel makes it from\n   * inside a change trail, on a path that builds. Unguarded, a single shadow-object that cannot cope\n   * with a single view event would leave through `Kernel.run()` and refuse the whole trail -- the\n   * same argument that puts a guard around the `onParentChanged` notification, which is a delivery\n   * on a building path as well. The guard is per event, so one that fails costs neither the events\n   * behind it nor the caller anything; `emitStrict()` inside it makes the same promise one level\n   * down, to the listeners of one event.\n   */\n  dispatchViewEvents(events: IComponentEvent[]) {\n    for (const {type, data} of events) {\n      runGuarded(\n        this.#kernel.logger,\n        // the concrete class is needed here: eventize cannot reduce its emitter conditional\n        // (`NonTypedEmitter<this>`) over the polymorphic `this` type, and no overload then matches\n        () => emitStrict(this as Entity, onViewEvent, type, data),\n        'entity view event delivery failed:',\n        type,\n        this.#uuid,\n      );\n    }\n  }\n\n  dispatchViewEvent(type: string, data: unknown) {\n    this.dispatchViewEvents([{type, data}]);\n  }\n\n  #getPropSignal<T = unknown>(key: string): Signal<T> {\n    return this.#props.get<T>(key);\n  }\n\n  getPropertyReader<T = unknown>(key: string): SignalReader<T> {\n    return this.#getPropSignal<T>(key).get;\n  }\n\n  /**\n   * A write head for one property. Every write through it drops the cache behind\n   * `truthyProps()`: that cache answers `Kernel.#updateShadowObjects()`, which picks the shadow\n   * objects of this entity along the property routes of the registry, and a write the cache does\n   * not see routes the entity to a state it no longer has.\n   *\n   * What comes back is a function of the entity, not the `set` of the signal behind the property.\n   * The signalize helpers that take a signal-like -- `isSignal()`, `destroySignal()`, `touch()` --\n   * do not recognise it; `getPropertyReader()` hands out the signal's own reader for that.\n   *\n   * A fresh closure is handed out on every call rather than one cached per key: `SignalAutoMap`\n   * hands out \"a fresh, live\" signal for a key whose signal was destroyed from the outside, so a\n   * writer cached against the signal captured on an earlier call could end up closing over a corpse.\n   * The call sites this feeds -- `setProperty()` from a change-trail application, at most once per\n   * property that actually changed -- do not turn this into a hot path.\n   */\n  getPropertyWriter<T = unknown>(key: string): SignalWriter<T> {\n    const signal = this.#getPropSignal<T>(key);\n    return (value: unknown, params?: SignalWriterParams<T>) => {\n      this.clearTruthyPropsCache();\n      signal.set(value as T, params);\n    };\n  }\n\n  setProperties(properties: ComponentPropertiesType) {\n    batch(() => {\n      // an entry that names only the key sets the property to `undefined` \u2014 the key is there, the value is not\n      for (const [key, val] of properties) {\n        this.setProperty(key, val);\n      }\n    });\n  }\n\n  setProperty(key: string, value: unknown) {\n    this.getPropertyWriter(key)(value);\n  }\n\n  getProperty<T = unknown>(key: string): T {\n    return value(this.getPropertyReader<T>(key));\n  }\n\n  propKeys(): string[] {\n    return Array.from(this.#props.keys()) as string[];\n  }\n\n  propEntries(): [string, unknown][] {\n    return Array.from(this.#props.entries()).map(([key, sig]) => [key, sig.value]) as [string, unknown][];\n  }\n\n  #truthyPropsCache: Set<string> | undefined;\n\n  clearTruthyPropsCache() {\n    this.#truthyPropsCache = undefined;\n  }\n\n  truthyProps(): Set<string> | undefined {\n    if (this.#truthyPropsCache) {\n      return this.#truthyPropsCache.size ? this.#truthyPropsCache : undefined;\n    }\n    const truthyProps = new Set<string>();\n    for (const [key, sig] of this.#props.entries()) {\n      if (typeof key === 'string') {\n        const val = sig.value;\n        if (val != null && val !== false && val !== '') {\n          truthyProps.add(key);\n        }\n      }\n    }\n    this.#truthyPropsCache = truthyProps;\n    return truthyProps.size ? truthyProps : undefined;\n  }\n\n  hasContext(name: ContextNameType): boolean {\n    return this.#context.has(name);\n  }\n\n  useContext<T = unknown>(name: ContextNameType): SignalReader<T> {\n    return this.#findOrCreateContext(name).context.get as SignalReader<T>;\n  }\n\n  useParentContext<T = unknown>(name: ContextNameType): SignalReader<T> {\n    return this.#findOrCreateContext(name).inherited.get as SignalReader<T>;\n  }\n\n  provideContext<T = unknown>(name: ContextNameType): Signal<T> {\n    return this.#findOrCreateContext(name).provide as Signal<T>;\n  }\n\n  provideGlobalContext<T = unknown>(name: ContextNameType): Signal<T> {\n    // The signal behind it is created without an initial value \u2014 a context signal does start out\n    // empty and holds no `T` until a provider writes one. The cast keeps the same contract\n    // `provideContext()` hands out; callers see the `undefined` through `Maybe<T>` in the\n    // shadow-object API.\n    return this.#findOrCreateGlobalContext(name).signal as Signal<T>;\n  }\n\n  /**\n   * Attaches a provider signal to the context of `name` on this entity and answers with the release\n   * that detaches it again.\n   *\n   * Every provider of one name writes into the single signal that `provideContext()` hands out, so\n   * what a consumer reads is what was written last. The release therefore does two things: it cuts\n   * this feed, and it then lets a provider that is still attached write its value once more. Without\n   * that second step the context would keep whatever the departure left standing -- the `undefined`\n   * of a clearing provider, or the last value of one that opted out of it -- even though this entity\n   * still has a provider of the name that says otherwise.\n   *\n   * A value written straight into the signal from `provideContext()` is not a feed and is therefore\n   * overwritten by the next release. Feeding a value in through this method is what makes it survive\n   * one.\n   */\n  attachContextProvider(name: ContextNameType, provider: Signal<any>): () => void {\n    const ctx = this.#findOrCreateContext(name);\n    return Entity.#attachProviderFeed(provider, ctx.provide, ctx.providerFeeds);\n  }\n\n  /**\n   * The counterpart of {@link Entity.attachContextProvider} for the global context of `name`.\n   *\n   * Within one entity the situation is the same one: every provider feeds the single signal this\n   * entity contributes to the kernel-wide chain of that name, and a release hands the name back to a\n   * provider that stays. Across entities the chain decides on its own -- it resolves to the first\n   * entry that holds something, so an entity whose signal falls empty lets the next one through.\n   */\n  attachGlobalContextProvider(name: ContextNameType, provider: Signal<any>): () => void {\n    const rootCtx = this.#findOrCreateGlobalContext(name);\n    return Entity.#attachProviderFeed(provider, rootCtx.signal, rootCtx.providerFeeds);\n  }\n\n  static #attachProviderFeed(provider: Signal<any>, target: Signal<any>, feeds: Set<SignalLink<any>>): () => void {\n    const feed = link(provider, target);\n    feeds.add(feed);\n\n    return () => {\n      // A release called a second time finds nothing of its own left and leaves the context to\n      // whoever holds it by then.\n      if (!feeds.delete(feed)) return;\n      feed.destroy();\n      Entity.#handOverToRemainingProvider(feeds);\n    };\n  }\n\n  /**\n   * Lets the provider that stays write its value into the context signal again.\n   *\n   * The set iterates in the order the providers were attached and the loop keeps the last hit, so the\n   * winner is the one attached last that still holds a value. Attachment order is the order in which the\n   * providers took the name: attaching feeds the value straight through, so a later attachment writes\n   * over an earlier one, and the hand-over falls back on that order instead of inventing one of its own.\n   * It is not the order of the writes -- a provider that writes to its signal after attaching carries\n   * the name until the next departure, and the hand-over does not restore that write, because what this\n   * entity keeps on file is its providers and not the sequence in which they wrote. Providers holding\n   * nothing are passed over -- by the same `!= null` rule with which `SignalsPath` resolves a context\n   * chain, and for the same reason: a provider without a value has nothing to say about the name, and\n   * electing it would clear a name that is still being provided.\n   *\n   * A feed whose link is destroyed is passed over as well. A shadow-object owns the signal it was\n   * handed and may end it early, which destroys the link without the release ever having run: such a\n   * feed still reports a value through its source while its writes go nowhere, so electing it would\n   * leave the write of the departure standing, silently and over a provider that is alive.\n   *\n   * `touch()` is what makes the winner write, because `SignalLink.write()` is protected: touching is\n   * the only public way to push the current value of a source through its link again, and the source\n   * of a provider that merely stays has no reason to change.\n   *\n   * Where no remaining feed qualifies, nothing is written: then what the departure left stands,\n   * which is the `undefined` of a clearing provider or the last value of one that opted out.\n   */\n  static #handOverToRemainingProvider(feeds: Set<SignalLink<any>>): void {\n    let winner: SignalLink<any> | undefined;\n    for (const feed of feeds) {\n      if (!feed.isDestroyed && feed.source.value != null) winner = feed;\n    }\n    winner?.touch();\n  }\n\n  #findOrCreateGlobalContext(name: ContextNameType): IRootContextValue {\n    if (this.#rootContexts.has(name)) {\n      return this.#rootContexts.get(name)!;\n    }\n    const rootCtx = this.#kernel.findOrCreateRootContext(name);\n    const signal = createSignal() as Signal<any>;\n    const cleanup = rootCtx.add(signal);\n    const ctx: IRootContextValue = {cleanup, signal, providerFeeds: new Set()};\n    this.#rootContexts.set(name, ctx);\n    return ctx;\n  }\n\n  #findOrCreateContext(name: ContextNameType): IContextValue {\n    if (this.#context.has(name)) {\n      return this.#context.get(name)!;\n    }\n\n    const inherited = createSignal();\n    const provide = createSignal();\n    const context = createSignal();\n\n    const valuePath = new SignalsPath([provide, inherited]);\n\n    const unsubscribePathValue = on(valuePath, SignalsPath.Value, (val) => {\n      deferContextValueUpdate(this.#kernel, context, val, name, this.#uuid);\n    });\n\n    const ctx: IContextValue = {name, inherited, provide, context, valuePath, providerFeeds: new Set(), unsubscribePathValue};\n    this.#context.set(name, ctx);\n\n    this.#subscribeToParent(ctx);\n\n    return ctx;\n  }\n\n  #subscribeToParent(ctx: IContextValue) {\n    ctx.unsubscribeFromParent?.();\n    ctx.unsubscribeFromParent = undefined;\n    if (this.parent) {\n      const parentCtx = this.parent.#findOrCreateContext(ctx.name);\n      const linkToParent = link(parentCtx.context, ctx.inherited);\n      ctx.unsubscribeFromParent = linkToParent.destroy.bind(linkToParent);\n    } else {\n      const rootCtx = this.#kernel.findOrCreateRootContext(ctx.name);\n      const linkToRoot = link(rootCtx.value$, ctx.inherited);\n      ctx.unsubscribeFromParent = linkToRoot.destroy.bind(linkToRoot);\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["value"]
 }