@spearwolf/shadow-objects 0.32.0 → 0.34.0

package/src/view/ShadowEnv.js

@@ -46,12 +46,33 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _proxyReady_dec, _viewReady_dec, _comCtx, _shaObjEnvProxy, _syncScheduled, _syncAfterContextCreated, _syncWaitForConfirmation, _afterNextSync, _init, _viewReady, _proxyReady, _isDestroyed, _syncIfScheduled, _ShadowEnv_instances, syncNow_fn, onMessageToView_fn;
-import { emit, off, on, onceAsync, Priority, retain, retainClear } from "@spearwolf/eventize";
-import { createEffect, createSignal, destroyObjectSignals, findObjectSignalByName } from "@spearwolf/signalize";
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _proxyReady_dec, _viewReady_dec, _comCtx, _shaObjEnvProxy, _syncScheduled, _syncAfterContextCreated, _syncWaitForConfirmation, _nextSyncCycle, _logger, _init, _viewReady, _proxyReady, _isDestroyed, _contextEffect, _ShadowEnv_instances, ensureContextEffect_fn, releaseNamespace_fn, _proxyGeneration, _whenDestroyed, _rejectWhenDestroyed, destroyedSignal_fn, openSyncCycle_fn, _syncIfScheduled, syncNow_fn, commitSyncCycle_fn, announceContext_fn, endSyncCycle_fn, onMessageToView_fn, onProxyFailed_fn;
+import { emitStrict, off, on, onceAsync, Priority, retain, retainClear } from "@spearwolf/eventize";
+import {
+  createEffect,
+  createSignal,
+  destroyObjectSignals,
+  findObjectSignalByName,
+  hibernate
+} from "@spearwolf/signalize";
 import { signal } from "@spearwolf/signalize/decorators";
+import { ChangeTrailRefusedError } from "../ChangeTrailRefusedError.js";
 import { ConsoleLogger } from "../utils/ConsoleLogger.js";
 import { ComponentContext } from "./ComponentContext.js";
+class ShadowEnvDestroyedError extends Error {
+  constructor(message = "the shadow environment has been destroyed") {
+    super(message);
+    this.name = "ShadowEnvDestroyedError";
+  }
+}
 _viewReady_dec = [signal()], _proxyReady_dec = [signal()];
 const _ShadowEnv = class _ShadowEnv {
   constructor() {
@@ -61,14 +82,33 @@ const _ShadowEnv = class _ShadowEnv {
     __privateAdd(this, _syncScheduled, false);
     __privateAdd(this, _syncAfterContextCreated, false);
     __privateAdd(this, _syncWaitForConfirmation, false);
-    __privateAdd(this, _afterNextSync);
-    this.logger = new ConsoleLogger("ShadowEnv");
+    __privateAdd(this, _nextSyncCycle);
+    __privateAdd(this, _logger, new ConsoleLogger("ShadowEnv"));
+    /**
+     * The namespace of the {@link ComponentContext} this environment observes, and `undefined`
+     * while it observes none. The `view` setter writes it, so it carries the name
+     * {@link ShadowEnv.get} finds this environment under, unless another environment has since
+     * taken that namespace over; a `destroy()` leaves it on `undefined`.
+     */
     this.ns$ = createSignal();
     __privateAdd(this, _viewReady, __runInitializers(_init, 8, this, false)), __runInitializers(_init, 11, this);
     __privateAdd(this, _proxyReady, __runInitializers(_init, 12, this, false)), __runInitializers(_init, 15, this);
     __privateAdd(this, _isDestroyed, false);
+    __privateAdd(this, _contextEffect);
+    // Each assignment to `envProxy` opens a generation. A start that finishes outside the generation
+    // it belongs to speaks for a proxy this environment has already let go, and is discarded.
+    __privateAdd(this, _proxyGeneration, 0);
+    __privateAdd(this, _whenDestroyed);
+    __privateAdd(this, _rejectWhenDestroyed);
+    /**
+     * Resolves once the environment is ready.
+     *
+     * @throws {ShadowEnvDestroyedError} if the environment is destroyed before that happens
+     */
     this.ready = async () => {
-      return this.isReady ? this : onceAsync(this, _ShadowEnv.ContextCreated);
+      if (__privateGet(this, _isDestroyed)) throw new ShadowEnvDestroyedError();
+      if (this.isReady) return this;
+      return Promise.race([onceAsync(this, _ShadowEnv.ContextCreated), __privateMethod(this, _ShadowEnv_instances, destroyedSignal_fn).call(this)]);
     };
     __privateAdd(this, _syncIfScheduled, () => {
       if (__privateGet(this, _syncScheduled)) {
@@ -77,27 +117,18 @@ const _ShadowEnv = class _ShadowEnv {
     });
     const self = this;
     retain(self, _ShadowEnv.ContextCreated);
-    on(self, _ShadowEnv.ContextLost, Priority.AAA, () => {
+    on(self, _ShadowEnv.ContextLost, Priority.Critical, () => {
       retainClear(self, _ShadowEnv.ContextCreated);
     });
-    createEffect(() => {
-      if (this.viewReady && this.proxyReady) {
-        this.view.reCreateChanges();
-        emit(self, _ShadowEnv.ContextCreated, self);
-        if (__privateGet(this, _syncAfterContextCreated)) {
-          __privateSet(this, _syncAfterContextCreated, false);
-          __privateMethod(this, _ShadowEnv_instances, syncNow_fn).call(this);
-        }
-        return () => {
-          emit(self, _ShadowEnv.ContextLost, self);
-        };
-      }
-    }, [findObjectSignalByName(this, "viewReady"), findObjectSignalByName(this, "proxyReady")]);
   }
   static get(ns) {
     if (ns == null) return void 0;
     return globalThis.__shadowEnvs?.get(ns);
   }
+  /** The logger this environment reports through. */
+  get logger() {
+    return __privateGet(this, _logger);
+  }
   get isDestroyed() {
     return __privateGet(this, _isDestroyed);
   }
@@ -106,23 +137,17 @@ const _ShadowEnv = class _ShadowEnv {
   }
   set view(ctx) {
     if (ctx !== __privateGet(this, _comCtx)) {
-      if (__privateGet(this, _comCtx) && __privateGet(this, _comCtx).ns && globalThis.__shadowEnvs) {
-        globalThis.__shadowEnvs.delete(__privateGet(this, _comCtx).ns);
-      }
+      if (ctx) __privateMethod(this, _ShadowEnv_instances, ensureContextEffect_fn).call(this);
+      __privateMethod(this, _ShadowEnv_instances, releaseNamespace_fn).call(this, __privateGet(this, _comCtx)?.ns);
       __privateSet(this, _comCtx, ctx ?? void 0);
-      if (__privateGet(this, _comCtx) && __privateGet(this, _comCtx).ns) {
+      if (__privateGet(this, _comCtx)?.ns) {
         globalThis.__shadowEnvs ??= /* @__PURE__ */ new Map();
         if (globalThis.__shadowEnvs.has(__privateGet(this, _comCtx).ns) && globalThis.__shadowEnvs.get(__privateGet(this, _comCtx).ns) !== this) {
-          if (this.logger.isWarn) {
-            this.logger.warn(
-              "overwrite a namespace already in use",
-              __privateGet(this, _comCtx).ns,
-              globalThis.__shadowEnvs.get(__privateGet(this, _comCtx).ns)
-            );
-          }
+          this.logger.warn("overwrite a namespace already in use", __privateGet(this, _comCtx).ns, globalThis.__shadowEnvs.get(__privateGet(this, _comCtx).ns));
         }
         globalThis.__shadowEnvs.set(__privateGet(this, _comCtx).ns, this);
       }
+      this.ns$.set(__privateGet(this, _comCtx)?.ns);
       this.viewReady = Boolean(ctx);
     }
   }
@@ -131,18 +156,27 @@ const _ShadowEnv = class _ShadowEnv {
   }
   set envProxy(proxy) {
     if (proxy !== __privateGet(this, _shaObjEnvProxy)) {
+      if (proxy) __privateMethod(this, _ShadowEnv_instances, ensureContextEffect_fn).call(this);
       const prevProxy = __privateGet(this, _shaObjEnvProxy);
       __privateSet(this, _shaObjEnvProxy, proxy ?? void 0);
+      const generation = ++__privateWrapper(this, _proxyGeneration)._;
       if (__privateGet(this, _shaObjEnvProxy)) {
         __privateGet(this, _shaObjEnvProxy).onMessageToView = __privateMethod(this, _ShadowEnv_instances, onMessageToView_fn).bind(this);
+        __privateGet(this, _shaObjEnvProxy).onProxyFailed = __privateMethod(this, _ShadowEnv_instances, onProxyFailed_fn).bind(this);
       }
       if (prevProxy) {
         prevProxy.destroy();
+        prevProxy.onProxyFailed = void 0;
+        queueMicrotask(() => {
+          prevProxy.onMessageToView = void 0;
+        });
       }
       this.proxyReady = false;
       proxy?.start().then(() => {
+        if (generation !== __privateGet(this, _proxyGeneration)) return;
         this.proxyReady = true;
       }).catch((error) => {
+        if (generation !== __privateGet(this, _proxyGeneration)) return;
         this.logger.error("failed to start envProxy", error);
         this.proxyReady = false;
       });
@@ -151,7 +185,23 @@ const _ShadowEnv = class _ShadowEnv {
   get isReady() {
     return Boolean(__privateGet(this, _comCtx) && __privateGet(this, _shaObjEnvProxy) && this.proxyReady && !this.isDestroyed);
   }
+  /**
+   * Send the change trail without asking the Shadow Environment to confirm it --
+   * {@link ShadowEnv.syncWait} is the call that asks.
+   *
+   * What becomes of a refusal is then the proxy's decision, and the two shipped ones differ.
+   * `LocalShadowObjectEnv` runs the Kernel synchronously, inside the call the environment makes to
+   * the proxy -- one microtask after `sync()` returned, not inside the call to `sync()` itself --
+   * and rejects with what it threw, so a refusal reaches {@link ShadowEnv.SyncFailed} here as well,
+   * carrying its number.
+   * `RemoteWorkerEnv` sends no serial without a confirmation and gets no answer back, so a
+   * refusal stays in the worker: it is written to the console there, `SyncFailed` stays silent, and
+   * the whole trail is booked as applied.
+   *
+   * {@link ShadowEnv.syncWait} is the way both proxies answer on.
+   */
   sync() {
+    if (__privateGet(this, _isDestroyed)) return;
     if (!this.isReady) {
       __privateSet(this, _syncAfterContextCreated, true);
       return;
@@ -160,31 +210,63 @@ const _ShadowEnv = class _ShadowEnv {
     __privateSet(this, _syncScheduled, true);
     queueMicrotask(__privateGet(this, _syncIfScheduled));
   }
+  /**
+   * Like {@link ShadowEnv.sync}, but resolves with the change trail once the cycle completed.
+   *
+   * A cycle whose change trail the Shadow Environment could not apply rejects instead, with the
+   * reason the proxy gave. Where the Kernel itself refused the trail that reason is a
+   * {@link ChangeTrailRefusedError}: it names how many entries the Kernel applied, this side folds
+   * exactly those into its bookkeeping, and everything behind that line stays pending and goes out
+   * again with the next cycle. A trail whose cause of refusal stays put is refused every time, which
+   * is what {@link ShadowEnv.SyncFailed} is the place to act on.
+   *
+   * A reason that says nothing about how far the Kernel got -- a confirmation window that ran out,
+   * a proxy whose environment is gone -- counts the whole trail as applied, because a Shadow
+   * Environment that fell silent may well hold all of it. Then the trail is gone, and only a
+   * re-creation from the Component Memory brings it back. That re-creation belongs to a fresh
+   * proxy: an environment that still holds the entities refuses a creation for a uuid it already
+   * has. Handing {@link ShadowEnv.envProxy} a new proxy is therefore the way back -- the Shadow
+   * Environment calls {@link ComponentContext.reCreateChanges} itself once the new proxy is ready.
+   * Making that call is the consumer's decision, the same way recovering from a
+   * {@link ShadowEnv.ProxyFailed} is.
+   *
+   * Which cycle a caller gets is decided when the change trail is built. Everyone who arrives
+   * before that point waits on the same promise -- they all ride the same trail. From the build
+   * on the trail is fixed, and a call after it belongs to the next cycle, the one that carries
+   * the changes made since. That holds inside a listener of {@link ShadowEnv.AfterSync} or
+   * {@link ShadowEnv.SyncFailed} as well: the cycle it was told about is over, so the call opens
+   * the one behind it.
+   *
+   * @throws {ShadowEnvDestroyedError} if the environment is destroyed before the cycle completes
+   */
   syncWait() {
+    if (__privateGet(this, _isDestroyed)) return Promise.reject(new ShadowEnvDestroyedError());
     __privateSet(this, _syncWaitForConfirmation, true);
     this.sync();
-    if (__privateGet(this, _afterNextSync)) return __privateGet(this, _afterNextSync);
-    __privateSet(this, _afterNextSync, onceAsync(this, _ShadowEnv.AfterSync).then((changeTrail) => {
-      __privateSet(this, _afterNextSync, void 0);
-      return changeTrail;
-    }));
-    return __privateGet(this, _afterNextSync);
+    __privateGet(this, _nextSyncCycle) ?? __privateSet(this, _nextSyncCycle, __privateMethod(this, _ShadowEnv_instances, openSyncCycle_fn).call(this));
+    return __privateGet(this, _nextSyncCycle).promise;
   }
+  /**
+   * Tear the environment down: the proxy is destroyed, the namespace is released, all signals
+   * and listeners are removed, and every caller still waiting on {@link ShadowEnv.ready} or
+   * {@link ShadowEnv.syncWait} is rejected with a {@link ShadowEnvDestroyedError} instead of
+   * being left pending forever. Calling it more than once is a no-op.
+   */
   destroy() {
-    const ns = __privateGet(this, _comCtx)?.ns;
-    this.envProxy?.destroy();
+    var _a;
+    if (__privateGet(this, _isDestroyed)) return;
+    __privateSet(this, _isDestroyed, true);
+    __privateSet(this, _syncScheduled, false);
+    __privateSet(this, _syncAfterContextCreated, false);
+    __privateSet(this, _syncWaitForConfirmation, false);
     this.envProxy = void 0;
     this.view = void 0;
-    if (ns) {
-      if (globalThis.__shadowEnvs.has(ns)) {
-        if (globalThis.__shadowEnvs.get(ns) === this) {
-          globalThis.__shadowEnvs.delete(ns);
-        }
-      }
-    }
+    (_a = __privateGet(this, _rejectWhenDestroyed)) == null ? void 0 : _a.call(this, new ShadowEnvDestroyedError());
+    __privateSet(this, _nextSyncCycle, void 0);
+    __privateGet(this, _contextEffect)?.destroy();
+    __privateSet(this, _contextEffect, void 0);
     destroyObjectSignals(this);
     off(this);
-    __privateSet(this, _isDestroyed, true);
     Object.freeze(this);
   }
 };
@@ -194,43 +276,198 @@ _shaObjEnvProxy = new WeakMap();
 _syncScheduled = new WeakMap();
 _syncAfterContextCreated = new WeakMap();
 _syncWaitForConfirmation = new WeakMap();
-_afterNextSync = new WeakMap();
+_nextSyncCycle = new WeakMap();
+_logger = new WeakMap();
 _viewReady = new WeakMap();
 _proxyReady = new WeakMap();
 _isDestroyed = new WeakMap();
-_syncIfScheduled = new WeakMap();
+_contextEffect = new WeakMap();
 _ShadowEnv_instances = new WeakSet();
+/**
+ * Builds the effect that reports {@link ShadowEnv.ContextCreated} and {@link ShadowEnv.ContextLost}
+ * once, on the first half of the environment that arrives.
+ */
+ensureContextEffect_fn = function() {
+  if (__privateGet(this, _isDestroyed) || __privateGet(this, _contextEffect) != null) return;
+  const self = this;
+  hibernate(() => {
+    __privateSet(this, _contextEffect, createEffect(() => {
+      if (this.viewReady && this.proxyReady) {
+        this.view.reCreateChanges();
+        __privateMethod(this, _ShadowEnv_instances, announceContext_fn).call(this, _ShadowEnv.ContextCreated, self);
+        if (__privateGet(this, _syncAfterContextCreated)) {
+          __privateSet(this, _syncAfterContextCreated, false);
+          __privateMethod(this, _ShadowEnv_instances, syncNow_fn).call(this);
+        }
+        return () => {
+          __privateMethod(this, _ShadowEnv_instances, announceContext_fn).call(this, _ShadowEnv.ContextLost, self);
+        };
+      }
+    }, [findObjectSignalByName(this, "viewReady"), findObjectSignalByName(this, "proxyReady")]));
+  });
+};
+/**
+ * Releases the namespace registration, but only while this environment holds it. A namespace
+ * carries one environment at a time, and an assignment that displaces another one leaves that
+ * other environment registered under nothing -- taking its entry along on the way out would
+ * make `ShadowEnv.get()` answer `undefined` for an environment that is very much alive.
+ */
+releaseNamespace_fn = function(ns) {
+  if (!ns) return;
+  const shadowEnvs = globalThis.__shadowEnvs;
+  if (shadowEnvs?.get(ns) === this) {
+    shadowEnvs.delete(ns);
+  }
+};
+_proxyGeneration = new WeakMap();
+_whenDestroyed = new WeakMap();
+_rejectWhenDestroyed = new WeakMap();
+/**
+ * A promise that rejects the moment this environment is destroyed.
+ *
+ * Every promise the public API hands out races against it. Without that race a caller
+ * would wait forever, because {@link ShadowEnv.destroy} tears down the very listeners
+ * those promises are built on.
+ */
+destroyedSignal_fn = function() {
+  if (__privateGet(this, _whenDestroyed) == null) {
+    __privateSet(this, _whenDestroyed, new Promise((_, reject) => {
+      __privateSet(this, _rejectWhenDestroyed, reject);
+    }));
+    __privateGet(this, _whenDestroyed).catch(() => {
+    });
+  }
+  return __privateGet(this, _whenDestroyed);
+};
+/**
+ * The cycle settles this promise by hand rather than through `AfterSync` / `SyncFailed`. A
+ * subscription made here would stand in line behind the listeners the application registered
+ * during setup, and an eventize emit stops at the first listener that throws -- everything
+ * behind it, this promise included, would be left waiting forever. Settling by hand also
+ * spares the bookkeeping a subscription per call would need: a cycle produces one of the two
+ * events, and the subscriber of the other one would stay behind and pile up.
+ */
+openSyncCycle_fn = function() {
+  let resolve;
+  let reject;
+  const outcome = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise: Promise.race([outcome, __privateMethod(this, _ShadowEnv_instances, destroyedSignal_fn).call(this)]), resolve, reject };
+};
+_syncIfScheduled = new WeakMap();
 syncNow_fn = async function() {
   __privateSet(this, _syncScheduled, false);
-  if (this.isReady) {
-    const data = this.view.buildChangeTrails();
+  if (__privateGet(this, _isDestroyed)) return;
+  if (!this.isReady) {
+    __privateSet(this, _syncAfterContextCreated, true);
+    return;
+  }
+  const data = this.view.buildChangeTrails(false);
+  const cycle = __privateGet(this, _nextSyncCycle);
+  __privateSet(this, _nextSyncCycle, void 0);
+  const waitForConfirmation = __privateGet(this, _syncWaitForConfirmation);
+  __privateSet(this, _syncWaitForConfirmation, false);
+  try {
     if (data.length > 0) {
-      try {
-        const waitForConfirmation = __privateGet(this, _syncWaitForConfirmation);
-        __privateSet(this, _syncWaitForConfirmation, false);
-        await this.envProxy.applyChangeTrail(data, waitForConfirmation);
-      } catch (error) {
-        this.logger.error("failed to apply change trail", error);
-      } finally {
-        emit(this, _ShadowEnv.AfterSync, data);
-      }
+      await this.envProxy.applyChangeTrail(data, waitForConfirmation);
     }
+  } catch (error) {
+    if (__privateGet(this, _isDestroyed)) return;
+    this.logger.error("failed to apply change trail", error);
+    __privateMethod(this, _ShadowEnv_instances, commitSyncCycle_fn).call(this, data, error);
+    __privateMethod(this, _ShadowEnv_instances, endSyncCycle_fn).call(this, data, cycle, { reason: error });
+    return;
   }
+  if (__privateGet(this, _isDestroyed)) return;
+  __privateMethod(this, _ShadowEnv_instances, commitSyncCycle_fn).call(this, data);
+  __privateMethod(this, _ShadowEnv_instances, endSyncCycle_fn).call(this, data, cycle);
 };
-onMessageToView_fn = function(event) {
-  if (this.logger.isDebug) {
-    this.logger.debug("onMessageToView", event.type, event.data);
+/**
+ * Draws the line between what the Shadow Environment applied and what it still owes, and hands
+ * it to the view. Runs ahead of {@link ShadowEnv.#endSyncCycle} so that a `SyncFailed` listener
+ * and a waiting {@link ShadowEnv.syncWait} caller find bookkeeping that already holds.
+ *
+ * An empty change trail is settled as well: the build may have retired components even without
+ * writing an entry for any of them.
+ */
+commitSyncCycle_fn = function(changeTrail, reason) {
+  const appliedCount = reason instanceof ChangeTrailRefusedError ? reason.appliedCount : changeTrail.length;
+  this.view?.commitChangeTrail(appliedCount, changeTrail);
+};
+/**
+ * Sends one of the two context events and keeps a listener that throws to itself.
+ *
+ * Both go out from inside the effect that watches `viewReady` and `proxyReady` -- `ContextLost`
+ * from its cleanup -- so a throw would leave through whatever signal write set that effect
+ * going, and reach code that has nothing to do with either event. `emitStrict()` serves every
+ * listener whatever the one before it did, and what they threw is reported here and travels no
+ * further.
+ */
+announceContext_fn = function(eventName, self) {
+  try {
+    emitStrict(self, eventName, self);
+  } catch (error) {
+    this.logger.error(`a ${eventName} listener threw`, error);
+  }
+};
+/**
+ * Ends a synchronization cycle in exactly one of its two outcomes. A cycle the Shadow
+ * Environment applied resolves {@link ShadowEnv.syncWait} and emits {@link ShadowEnv.AfterSync};
+ * a cycle whose change trail it refused rejects and emits {@link ShadowEnv.SyncFailed}. Only a
+ * listener that can tell the two apart can react to either, so no cycle ever sends both.
+ *
+ * The waiting caller is settled before the event goes out, and the emit is the last thing that
+ * happens: a settlement that travelled as a listener of its own would sit behind whatever the
+ * application registered during setup, and this method is the wrong place to make a promise
+ * depend on the order consumers subscribe in. The dispatch is `emitStrict()`, so every listener
+ * hears about the cycle whatever the one before it did, and what they threw arrives here
+ * afterwards -- one of them unchanged, several as an `AggregateError` in dispatch order. It ends
+ * here as well: `#syncNow()` runs unawaited, and an error escaping it becomes an unhandled
+ * rejection rather than a report anybody reads.
+ *
+ * Which cycle is being ended arrives as an argument: the caller carries it from the moment its
+ * change trail was built, so a cycle that is still in flight cannot be settled by the one behind it.
+ */
+endSyncCycle_fn = function(changeTrail, cycle, failure) {
+  try {
+    if (failure) {
+      cycle?.reject(failure.reason);
+      emitStrict(this, _ShadowEnv.SyncFailed, failure.reason, changeTrail, this);
+    } else {
+      cycle?.resolve(changeTrail);
+      emitStrict(this, _ShadowEnv.AfterSync, changeTrail);
+    }
+  } catch (error) {
+    this.logger.error("a sync cycle listener threw", error);
   }
+};
+onMessageToView_fn = function(event) {
+  this.logger.debug("onMessageToView", event.type, event.data);
   this.view?.dispatchMessage(event.uuid, event.type, event.data, event.traverseChildren);
 };
+onProxyFailed_fn = function(reason) {
+  if (__privateGet(this, _isDestroyed)) return;
+  this.logger.error("the environment proxy failed", reason);
+  ++__privateWrapper(this, _proxyGeneration)._;
+  try {
+    emitStrict(this, _ShadowEnv.ProxyFailed, reason, this);
+  } finally {
+    this.proxyReady = false;
+  }
+};
 __decorateElement(_init, 4, "viewReady", _viewReady_dec, _ShadowEnv, _viewReady);
 __decorateElement(_init, 4, "proxyReady", _proxyReady_dec, _ShadowEnv, _proxyReady);
 __decoratorMetadata(_init, _ShadowEnv);
 _ShadowEnv.AfterSync = "afterSync";
+_ShadowEnv.SyncFailed = "syncFailed";
 _ShadowEnv.ContextLost = "contextLost";
 _ShadowEnv.ContextCreated = "contextCreated";
+_ShadowEnv.ProxyFailed = "proxyFailed";
 let ShadowEnv = _ShadowEnv;
 export {
-  ShadowEnv
+  ShadowEnv,
+  ShadowEnvDestroyedError
 };
 //# sourceMappingURL=ShadowEnv.js.map

package/src/view/ShadowEnv.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/view/ShadowEnv.ts"],
-  "sourcesContent": ["import {emit, off, on, onceAsync, Priority, retain, retainClear} from '@spearwolf/eventize';\nimport {createEffect, createSignal, destroyObjectSignals, findObjectSignalByName} from '@spearwolf/signalize';\nimport {signal} from '@spearwolf/signalize/decorators';\nimport type {MessageToViewEvent} from '../shadow-objects.js';\nimport type {ChangeTrailType, NamespaceType} from '../types.js';\nimport {ConsoleLogger} from '../utils/ConsoleLogger.js';\nimport {ComponentContext} from './ComponentContext.js';\nimport type {IShadowObjectEnvProxy} from './IShadowObjectEnvProxy.js';\n\ndeclare global {\n  // eslint-disable-next-line no-var\n  var __shadowEnvs: Map<NamespaceType, ShadowEnv> | undefined;\n}\n\nexport class ShadowEnv {\n  static AfterSync = 'afterSync';\n  static ContextLost = 'contextLost';\n  static ContextCreated = 'contextCreated';\n\n  static get(ns: NamespaceType): ShadowEnv | undefined {\n    if (ns == null) return undefined;\n    return globalThis.__shadowEnvs?.get(ns);\n  }\n\n  #comCtx?: ComponentContext;\n  #shaObjEnvProxy?: IShadowObjectEnvProxy;\n  #syncScheduled = false;\n  #syncAfterContextCreated = false;\n  #syncWaitForConfirmation = false;\n  #afterNextSync?: Promise<ChangeTrailType>;\n\n  readonly logger = new ConsoleLogger('ShadowEnv');\n\n  readonly ns$ = createSignal<NamespaceType | undefined>();\n\n  @signal() accessor viewReady = false;\n  @signal() accessor proxyReady = false;\n\n  #isDestroyed = false;\n\n  get isDestroyed() {\n    return this.#isDestroyed;\n  }\n\n  constructor() {\n    const self = this as ShadowEnv;\n    retain(self, ShadowEnv.ContextCreated);\n\n    on(self, ShadowEnv.ContextLost, Priority.AAA, () => {\n      retainClear(self, ShadowEnv.ContextCreated);\n    });\n\n    createEffect(() => {\n      if (this.viewReady && this.proxyReady) {\n        this.view!.reCreateChanges();\n        emit(self, ShadowEnv.ContextCreated, self);\n        if (this.#syncAfterContextCreated) {\n          this.#syncAfterContextCreated = false;\n          this.#syncNow();\n        }\n        return () => {\n          emit(self, ShadowEnv.ContextLost, self);\n        };\n      }\n    }, [findObjectSignalByName(this, 'viewReady'), findObjectSignalByName(this, 'proxyReady')]);\n  }\n\n  get view(): ComponentContext | undefined {\n    return this.#comCtx;\n  }\n\n  set view(ctx: ComponentContext | null | undefined) {\n    if (ctx !== this.#comCtx) {\n      if (this.#comCtx && this.#comCtx.ns && globalThis.__shadowEnvs) {\n        globalThis.__shadowEnvs.delete(this.#comCtx.ns);\n      }\n\n      this.#comCtx = ctx ?? undefined;\n\n      if (this.#comCtx && this.#comCtx.ns) {\n        globalThis.__shadowEnvs ??= new Map();\n        if (globalThis.__shadowEnvs.has(this.#comCtx.ns) && globalThis.__shadowEnvs.get(this.#comCtx.ns) !== this) {\n          if (this.logger.isWarn) {\n            this.logger.warn(\n              'overwrite a namespace already in use',\n              this.#comCtx.ns,\n              globalThis.__shadowEnvs.get(this.#comCtx.ns),\n            );\n          }\n        }\n        globalThis.__shadowEnvs.set(this.#comCtx.ns, this);\n      }\n\n      this.viewReady = Boolean(ctx);\n    }\n  }\n\n  get envProxy(): IShadowObjectEnvProxy | undefined {\n    return this.#shaObjEnvProxy;\n  }\n\n  set envProxy(proxy: IShadowObjectEnvProxy | null | undefined) {\n    if (proxy !== this.#shaObjEnvProxy) {\n      const prevProxy = this.#shaObjEnvProxy;\n      this.#shaObjEnvProxy = proxy ?? undefined;\n\n      if (this.#shaObjEnvProxy) {\n        this.#shaObjEnvProxy.onMessageToView = this.#onMessageToView.bind(this);\n      }\n\n      if (prevProxy) {\n        prevProxy.destroy();\n      }\n\n      this.proxyReady = false;\n\n      proxy\n        ?.start()\n        .then(() => {\n          this.proxyReady = true;\n        })\n        .catch((error) => {\n          this.logger.error('failed to start envProxy', error);\n          this.proxyReady = false;\n        });\n    }\n  }\n\n  get isReady(): boolean {\n    return Boolean(this.#comCtx && this.#shaObjEnvProxy && this.proxyReady && !this.isDestroyed);\n  }\n\n  readonly ready = async (): Promise<ShadowEnv> => {\n    return this.isReady ? this : onceAsync(this as ShadowEnv, ShadowEnv.ContextCreated);\n  };\n\n  sync(): void {\n    if (!this.isReady) {\n      this.#syncAfterContextCreated = true;\n      return;\n    }\n    if (this.#syncScheduled) return;\n    this.#syncScheduled = true;\n    queueMicrotask(this.#syncIfScheduled);\n  }\n\n  syncWait(): Promise<ChangeTrailType> {\n    this.#syncWaitForConfirmation = true;\n    this.sync();\n    if (this.#afterNextSync) return this.#afterNextSync;\n    this.#afterNextSync = onceAsync<ChangeTrailType>(this as ShadowEnv, ShadowEnv.AfterSync).then((changeTrail) => {\n      this.#afterNextSync = undefined;\n      return changeTrail;\n    });\n    return this.#afterNextSync;\n  }\n\n  destroy() {\n    const ns = this.#comCtx?.ns;\n\n    this.envProxy?.destroy();\n    this.envProxy = undefined;\n    this.view = undefined;\n\n    if (ns) {\n      if (globalThis.__shadowEnvs.has(ns)) {\n        if (globalThis.__shadowEnvs.get(ns) === this) {\n          globalThis.__shadowEnvs.delete(ns);\n        }\n      }\n    }\n\n    destroyObjectSignals(this);\n    off(this);\n\n    this.#isDestroyed = true;\n    Object.freeze(this);\n  }\n\n  #syncIfScheduled = () => {\n    if (this.#syncScheduled) {\n      this.#syncNow();\n    }\n  };\n\n  async #syncNow() {\n    this.#syncScheduled = false;\n    if (this.isReady) {\n      const data = this.view!.buildChangeTrails();\n      if (data.length > 0) {\n        try {\n          const waitForConfirmation = this.#syncWaitForConfirmation;\n          this.#syncWaitForConfirmation = false;\n          await this.envProxy!.applyChangeTrail(data, waitForConfirmation);\n        } catch (error) {\n          this.logger.error('failed to apply change trail', error);\n        } finally {\n          emit(this as ShadowEnv, ShadowEnv.AfterSync, data);\n        }\n      }\n    }\n  }\n\n  #onMessageToView(event: Omit<MessageToViewEvent, 'transferables'>) {\n    if (this.logger.isDebug) {\n      this.logger.debug('onMessageToView', event.type, event.data);\n    }\n    this.view?.dispatchMessage(event.uuid, event.type, event.data, event.traverseChildren);\n  }\n}"],
-  "mappings": "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",
+  "sourcesContent": ["import {emitStrict, off, on, onceAsync, Priority, retain, retainClear} from '@spearwolf/eventize';\nimport {\n  createEffect,\n  createSignal,\n  destroyObjectSignals,\n  type Effect,\n  findObjectSignalByName,\n  hibernate,\n} from '@spearwolf/signalize';\nimport {signal} from '@spearwolf/signalize/decorators';\nimport {ChangeTrailRefusedError} from '../ChangeTrailRefusedError.js';\nimport type {MessageToViewEvent} from '../shadow-objects.js';\nimport type {ChangeTrailType, NamespaceType} from '../types.js';\nimport {ConsoleLogger} from '../utils/ConsoleLogger.js';\nimport {ComponentContext} from './ComponentContext.js';\nimport type {IShadowObjectEnvProxy} from './IShadowObjectEnvProxy.js';\n\ndeclare global {\n  var __shadowEnvs: Map<NamespaceType, ShadowEnv> | undefined;\n}\n\n/**\n * The reason every pending {@link ShadowEnv.ready} and {@link ShadowEnv.syncWait} promise\n * is rejected with when the environment is destroyed.\n */\nexport class ShadowEnvDestroyedError extends Error {\n  constructor(message = 'the shadow environment has been destroyed') {\n    super(message);\n    this.name = 'ShadowEnvDestroyedError';\n  }\n}\n\n/**\n * The settlement of one synchronization cycle: the promise `syncWait()` hands out, and the pair\n * that settles it. A cycle takes its own settlement with it the moment its change trail is\n * built, which is what lets two cycles be in flight at once without settling each other's\n * callers.\n */\ntype SyncCycle = {\n  promise: Promise<ChangeTrailType>;\n  resolve: (changeTrail: ChangeTrailType) => void;\n  reject: (reason: unknown) => void;\n};\n\nexport class ShadowEnv {\n  static AfterSync = 'afterSync';\n  static SyncFailed = 'syncFailed';\n  static ContextLost = 'contextLost';\n  static ContextCreated = 'contextCreated';\n  static ProxyFailed = 'proxyFailed';\n\n  static get(ns: NamespaceType): ShadowEnv | undefined {\n    if (ns == null) return undefined;\n    return globalThis.__shadowEnvs?.get(ns);\n  }\n\n  #comCtx?: ComponentContext | undefined;\n  #shaObjEnvProxy?: IShadowObjectEnvProxy | undefined;\n  #syncScheduled = false;\n  #syncAfterContextCreated = false;\n  #syncWaitForConfirmation = false;\n  #nextSyncCycle?: SyncCycle | undefined;\n\n  readonly #logger = new ConsoleLogger('ShadowEnv');\n\n  /** The logger this environment reports through. */\n  get logger(): ConsoleLogger {\n    return this.#logger;\n  }\n\n  /**\n   * The namespace of the {@link ComponentContext} this environment observes, and `undefined`\n   * while it observes none. The `view` setter writes it, so it carries the name\n   * {@link ShadowEnv.get} finds this environment under, unless another environment has since\n   * taken that namespace over; a `destroy()` leaves it on `undefined`.\n   */\n  readonly ns$ = createSignal<NamespaceType | undefined>();\n\n  @signal() accessor viewReady = false;\n  @signal() accessor proxyReady = false;\n\n  #isDestroyed = false;\n\n  get isDestroyed() {\n    return this.#isDestroyed;\n  }\n\n  constructor() {\n    const self = this as ShadowEnv;\n    retain(self, ShadowEnv.ContextCreated);\n\n    on(self, ShadowEnv.ContextLost, Priority.Critical, () => {\n      retainClear(self, ShadowEnv.ContextCreated);\n    });\n\n    // the effect that reports the context comes with the first `view` or `envProxy` this\n    // environment is given: an effect stands in a module-wide queue until it is destroyed, and an\n    // environment that never receives either half must stay collectable\n  }\n\n  #contextEffect?: Effect | undefined;\n\n  /**\n   * Builds the effect that reports {@link ShadowEnv.ContextCreated} and {@link ShadowEnv.ContextLost}\n   * once, on the first half of the environment that arrives.\n   */\n  #ensureContextEffect(): void {\n    if (this.#isDestroyed || this.#contextEffect != null) return;\n\n    const self = this as ShadowEnv;\n\n    // `hibernate()` clears the effect stack for the duration, and that is not optional here. Both\n    // setters below are public API and are called from application code that may well sit inside a\n    // `createEffect()` -- `<shae-worker>` is one such caller: it assigns `view` from inside an\n    // `ns$.onChange()` callback. An effect built while a foreign effect is running becomes that\n    // effect's child and dies at its next run, taking the context reports with it. The three custom\n    // elements shield their `connectedCallback` the same way.\n    //\n    // One observable side effect comes with it: a `batch()` the caller has open is pushed through\n    // before this returns, so the effects it was holding back run at this point. The writes the\n    // setter makes afterwards go back into that batch and wait for it to close, the way they would\n    // without any of this.\n    hibernate(() => {\n      this.#contextEffect = createEffect(() => {\n        if (this.viewReady && this.proxyReady) {\n          // Both halves being ready is what this reacts to, and either half can be the one that\n          // arrived last. A fresh proxy under the standing view is the case the recovery is written\n          // for: it holds none of the uuids, and the re-created trail goes through. A view that is\n          // taken off and hung back on -- `env.view = undefined; env.view = ctx`, and `get(ns)`\n          // hands back the very same context -- is the one that does not: its memory is still full,\n          // the proxy that stayed still holds every uuid in it, and the trail is refused at its\n          // first creation and stays refused. A context that is genuinely new carries an empty\n          // memory and re-creates nothing at all. Whoever swaps the view of a live environment\n          // tears the proxy down with it.\n          this.view!.reCreateChanges();\n          this.#announceContext(ShadowEnv.ContextCreated, self);\n          if (this.#syncAfterContextCreated) {\n            this.#syncAfterContextCreated = false;\n            this.#syncNow();\n          }\n          return () => {\n            this.#announceContext(ShadowEnv.ContextLost, self);\n          };\n        }\n        // the two @signal accessors above create their signals during field initialization,\n        // so both lookups resolve by the time a setter runs\n      }, [findObjectSignalByName(this, 'viewReady')!, findObjectSignalByName(this, 'proxyReady')!]);\n    });\n  }\n\n  get view(): ComponentContext | undefined {\n    return this.#comCtx;\n  }\n\n  set view(ctx: ComponentContext | null | undefined) {\n    if (ctx !== this.#comCtx) {\n      if (ctx) this.#ensureContextEffect();\n\n      this.#releaseNamespace(this.#comCtx?.ns);\n\n      this.#comCtx = ctx ?? undefined;\n\n      if (this.#comCtx?.ns) {\n        globalThis.__shadowEnvs ??= new Map();\n        if (globalThis.__shadowEnvs.has(this.#comCtx.ns) && globalThis.__shadowEnvs.get(this.#comCtx.ns) !== this) {\n          this.logger.warn('overwrite a namespace already in use', this.#comCtx.ns, globalThis.__shadowEnvs.get(this.#comCtx.ns));\n        }\n        globalThis.__shadowEnvs.set(this.#comCtx.ns, this);\n      }\n\n      // the namespace this environment observes, published where the name promises it. `view` is\n      // the only way one reaches this object -- `ComponentContext.ns` is assigned in its\n      // constructor and never again -- and the write stands behind the registration above, so\n      // whoever reacts to it finds `ShadowEnv.get()` already answering this environment. It needs\n      // no truthiness guard of its own: `toNamespace()` turns an empty or whitespace-only string\n      // into `GlobalNS`, so a context that exists has a namespace that registers.\n      this.ns$.set(this.#comCtx?.ns);\n\n      this.viewReady = Boolean(ctx);\n    }\n  }\n\n  /**\n   * Releases the namespace registration, but only while this environment holds it. A namespace\n   * carries one environment at a time, and an assignment that displaces another one leaves that\n   * other environment registered under nothing -- taking its entry along on the way out would\n   * make `ShadowEnv.get()` answer `undefined` for an environment that is very much alive.\n   */\n  #releaseNamespace(ns: NamespaceType | undefined): void {\n    // the same truthiness check the `view` setter above uses before it registers a namespace,\n    // so release and registration recognize the same namespace as \"none\"\n    if (!ns) return;\n    const shadowEnvs = globalThis.__shadowEnvs;\n    if (shadowEnvs?.get(ns) === this) {\n      shadowEnvs.delete(ns);\n    }\n  }\n\n  get envProxy(): IShadowObjectEnvProxy | undefined {\n    return this.#shaObjEnvProxy;\n  }\n\n  // Each assignment to `envProxy` opens a generation. A start that finishes outside the generation\n  // it belongs to speaks for a proxy this environment has already let go, and is discarded.\n  #proxyGeneration = 0;\n\n  set envProxy(proxy: IShadowObjectEnvProxy | null | undefined) {\n    if (proxy !== this.#shaObjEnvProxy) {\n      if (proxy) this.#ensureContextEffect();\n\n      const prevProxy = this.#shaObjEnvProxy;\n      this.#shaObjEnvProxy = proxy ?? undefined;\n\n      const generation = ++this.#proxyGeneration;\n\n      if (this.#shaObjEnvProxy) {\n        this.#shaObjEnvProxy.onMessageToView = this.#onMessageToView.bind(this);\n        this.#shaObjEnvProxy.onProxyFailed = this.#onProxyFailed.bind(this);\n      }\n\n      if (prevProxy) {\n        prevProxy.destroy();\n\n        // a proxy this environment has let go speaks for an environment that is gone; whatever\n        // it makes of its own failure from here on is no longer this environment's business\n        prevProxy.onProxyFailed = undefined;\n\n        // one microtask later, not synchronously: a local environment hands a message an\n        // `onDestroy` sends towards the view to a microtask queued while `destroy()` runs, and\n        // that message is still addressed to this environment. The microtask queue is served in\n        // the order it was filled, so every message the teardown queued runs ahead of this line\n        // -- and the released proxy falls silent for everything after it\n        queueMicrotask(() => {\n          prevProxy.onMessageToView = undefined;\n        });\n      }\n\n      this.proxyReady = false;\n\n      // the catch stays behind the then: a listener of ContextCreated that throws is reported here,\n      // and turning this into `then(onFulfilled, onRejected)` would let it escape as an unhandled rejection\n      proxy\n        ?.start()\n        .then(() => {\n          if (generation !== this.#proxyGeneration) return;\n          this.proxyReady = true;\n        })\n        .catch((error) => {\n          if (generation !== this.#proxyGeneration) return;\n          this.logger.error('failed to start envProxy', error);\n          this.proxyReady = false;\n        });\n    }\n  }\n\n  get isReady(): boolean {\n    return Boolean(this.#comCtx && this.#shaObjEnvProxy && this.proxyReady && !this.isDestroyed);\n  }\n\n  #whenDestroyed?: Promise<never>;\n  #rejectWhenDestroyed?: (error: Error) => void;\n\n  /**\n   * A promise that rejects the moment this environment is destroyed.\n   *\n   * Every promise the public API hands out races against it. Without that race a caller\n   * would wait forever, because {@link ShadowEnv.destroy} tears down the very listeners\n   * those promises are built on.\n   */\n  #destroyedSignal(): Promise<never> {\n    if (this.#whenDestroyed == null) {\n      this.#whenDestroyed = new Promise<never>((_, reject) => {\n        this.#rejectWhenDestroyed = reject;\n      });\n      // the signal is rejected unconditionally, also when nobody happens to be racing against it\n      this.#whenDestroyed.catch(() => {});\n    }\n    return this.#whenDestroyed;\n  }\n\n  /**\n   * Resolves once the environment is ready.\n   *\n   * @throws {ShadowEnvDestroyedError} if the environment is destroyed before that happens\n   */\n  readonly ready = async (): Promise<ShadowEnv> => {\n    if (this.#isDestroyed) throw new ShadowEnvDestroyedError();\n    if (this.isReady) return this;\n    return Promise.race([onceAsync<ShadowEnv>(this as ShadowEnv, ShadowEnv.ContextCreated), this.#destroyedSignal()]);\n  };\n\n  /**\n   * Send the change trail without asking the Shadow Environment to confirm it --\n   * {@link ShadowEnv.syncWait} is the call that asks.\n   *\n   * What becomes of a refusal is then the proxy's decision, and the two shipped ones differ.\n   * `LocalShadowObjectEnv` runs the Kernel synchronously, inside the call the environment makes to\n   * the proxy -- one microtask after `sync()` returned, not inside the call to `sync()` itself --\n   * and rejects with what it threw, so a refusal reaches {@link ShadowEnv.SyncFailed} here as well,\n   * carrying its number.\n   * `RemoteWorkerEnv` sends no serial without a confirmation and gets no answer back, so a\n   * refusal stays in the worker: it is written to the console there, `SyncFailed` stays silent, and\n   * the whole trail is booked as applied.\n   *\n   * {@link ShadowEnv.syncWait} is the way both proxies answer on.\n   */\n  sync(): void {\n    if (this.#isDestroyed) return;\n    if (!this.isReady) {\n      this.#syncAfterContextCreated = true;\n      return;\n    }\n    if (this.#syncScheduled) return;\n    this.#syncScheduled = true;\n    queueMicrotask(this.#syncIfScheduled);\n  }\n\n  /**\n   * Like {@link ShadowEnv.sync}, but resolves with the change trail once the cycle completed.\n   *\n   * A cycle whose change trail the Shadow Environment could not apply rejects instead, with the\n   * reason the proxy gave. Where the Kernel itself refused the trail that reason is a\n   * {@link ChangeTrailRefusedError}: it names how many entries the Kernel applied, this side folds\n   * exactly those into its bookkeeping, and everything behind that line stays pending and goes out\n   * again with the next cycle. A trail whose cause of refusal stays put is refused every time, which\n   * is what {@link ShadowEnv.SyncFailed} is the place to act on.\n   *\n   * A reason that says nothing about how far the Kernel got -- a confirmation window that ran out,\n   * a proxy whose environment is gone -- counts the whole trail as applied, because a Shadow\n   * Environment that fell silent may well hold all of it. Then the trail is gone, and only a\n   * re-creation from the Component Memory brings it back. That re-creation belongs to a fresh\n   * proxy: an environment that still holds the entities refuses a creation for a uuid it already\n   * has. Handing {@link ShadowEnv.envProxy} a new proxy is therefore the way back -- the Shadow\n   * Environment calls {@link ComponentContext.reCreateChanges} itself once the new proxy is ready.\n   * Making that call is the consumer's decision, the same way recovering from a\n   * {@link ShadowEnv.ProxyFailed} is.\n   *\n   * Which cycle a caller gets is decided when the change trail is built. Everyone who arrives\n   * before that point waits on the same promise -- they all ride the same trail. From the build\n   * on the trail is fixed, and a call after it belongs to the next cycle, the one that carries\n   * the changes made since. That holds inside a listener of {@link ShadowEnv.AfterSync} or\n   * {@link ShadowEnv.SyncFailed} as well: the cycle it was told about is over, so the call opens\n   * the one behind it.\n   *\n   * @throws {ShadowEnvDestroyedError} if the environment is destroyed before the cycle completes\n   */\n  syncWait(): Promise<ChangeTrailType> {\n    if (this.#isDestroyed) return Promise.reject(new ShadowEnvDestroyedError());\n\n    this.#syncWaitForConfirmation = true;\n    this.sync();\n\n    // Every caller that arrives before the change trail is built waits on the same promise: they\n    // all ride the same trail. From the build on the trail is fixed, `#syncNow()` has taken this\n    // cycle with it, and the next caller opens the one behind it -- the cycle that will carry the\n    // change they are about to make.\n    this.#nextSyncCycle ??= this.#openSyncCycle();\n\n    return this.#nextSyncCycle.promise;\n  }\n\n  /**\n   * The cycle settles this promise by hand rather than through `AfterSync` / `SyncFailed`. A\n   * subscription made here would stand in line behind the listeners the application registered\n   * during setup, and an eventize emit stops at the first listener that throws -- everything\n   * behind it, this promise included, would be left waiting forever. Settling by hand also\n   * spares the bookkeeping a subscription per call would need: a cycle produces one of the two\n   * events, and the subscriber of the other one would stay behind and pile up.\n   */\n  #openSyncCycle(): SyncCycle {\n    let resolve!: (changeTrail: ChangeTrailType) => void;\n    let reject!: (reason: unknown) => void;\n\n    const outcome = new Promise<ChangeTrailType>((res, rej) => {\n      resolve = res;\n      reject = rej;\n    });\n\n    // the race is what settles a caller whose environment is destroyed before the cycle ends:\n    // `destroy()` tears down the very listeners any other route would depend on\n    return {promise: Promise.race([outcome, this.#destroyedSignal()]), resolve, reject};\n  }\n\n  /**\n   * Tear the environment down: the proxy is destroyed, the namespace is released, all signals\n   * and listeners are removed, and every caller still waiting on {@link ShadowEnv.ready} or\n   * {@link ShadowEnv.syncWait} is rejected with a {@link ShadowEnvDestroyedError} instead of\n   * being left pending forever. Calling it more than once is a no-op.\n   */\n  destroy() {\n    if (this.#isDestroyed) return;\n\n    // set first: isReady must report false for everything that runs below\n    this.#isDestroyed = true;\n\n    this.#syncScheduled = false;\n    this.#syncAfterContextCreated = false;\n    this.#syncWaitForConfirmation = false;\n\n    // the `envProxy` setter destroys the previous proxy, so it must not be destroyed here as well\n    this.envProxy = undefined;\n    // the `view` setter releases the namespace registration on the way out, ownership-checked, and clears `ns$` with it\n    this.view = undefined;\n\n    // settle everyone still waiting before the listeners they depend on are removed\n    this.#rejectWhenDestroyed?.(new ShadowEnvDestroyedError());\n    this.#nextSyncCycle = undefined;\n\n    // The effect is built here, so it is released here: its lifetime hangs on this class rather\n    // than on what a reactivity library makes of an effect whose dependencies are taken away.\n    // `ContextLost` goes out exactly once, from whichever of the two gets there first: the effect\n    // rerun that `this.envProxy = undefined` triggers above, or -- while an open `batch()` parks\n    // that drop of `proxyReady` -- the destroy on this line. A cleanup function belongs to the run\n    // that returned it, and is spent by the one that runs it.\n    this.#contextEffect?.destroy();\n    this.#contextEffect = undefined;\n\n    destroyObjectSignals(this);\n    off(this);\n\n    Object.freeze(this);\n  }\n\n  #syncIfScheduled = () => {\n    if (this.#syncScheduled) {\n      this.#syncNow();\n    }\n  };\n\n  async #syncNow() {\n    this.#syncScheduled = false;\n\n    if (this.#isDestroyed) return;\n\n    if (!this.isReady) {\n      // the environment went away between scheduling and running this sync:\n      // re-arm instead of dropping it, otherwise a pending syncWait() would never settle\n      this.#syncAfterContextCreated = true;\n      return;\n    }\n\n    const data = this.view!.buildChangeTrails(false);\n\n    // The trail is fixed from here on, and with it the set of callers this cycle answers: it\n    // leaves holding `#nextSyncCycle`, and a `syncWait()` from now on opens the cycle behind it.\n    // The settlement travels in this frame rather than in a field, because two cycles can be in\n    // flight at once -- `ComponentContext.buildChangeTrails()` says as much at its own end of this.\n    const cycle = this.#nextSyncCycle;\n    this.#nextSyncCycle = undefined;\n\n    const waitForConfirmation = this.#syncWaitForConfirmation;\n    this.#syncWaitForConfirmation = false;\n\n    try {\n      if (data.length > 0) {\n        await this.envProxy!.applyChangeTrail(data, waitForConfirmation);\n      }\n    } catch (error) {\n      // an environment that was torn down while its trail was in flight ends its cycle in silence:\n      // destroy() has already rejected whoever waited on it and taken the listeners off, and a proxy\n      // that refuses because it is being destroyed is not a failure anybody needs reported. The same\n      // guard `#onProxyFailed()` carries at the neighbouring spot.\n      if (this.#isDestroyed) return;\n\n      // the log entry before anything else: what went wrong is on the record even if the report\n      // of it runs into a listener that cannot cope\n      this.logger.error('failed to apply change trail', error);\n      this.#commitSyncCycle(data, error);\n      this.#endSyncCycle(data, cycle, {reason: error});\n      return;\n    }\n\n    if (this.#isDestroyed) return;\n\n    // an empty change trail ends here as well -- nothing is sent, so nothing can be refused\n    this.#commitSyncCycle(data);\n    this.#endSyncCycle(data, cycle);\n  }\n\n  /**\n   * Draws the line between what the Shadow Environment applied and what it still owes, and hands\n   * it to the view. Runs ahead of {@link ShadowEnv.#endSyncCycle} so that a `SyncFailed` listener\n   * and a waiting {@link ShadowEnv.syncWait} caller find bookkeeping that already holds.\n   *\n   * An empty change trail is settled as well: the build may have retired components even without\n   * writing an entry for any of them.\n   */\n  #commitSyncCycle(changeTrail: ChangeTrailType, reason?: unknown): void {\n    // A reason that does not say how far the Kernel got says nothing about the trail either: a\n    // confirmation window that ran out leaves an environment that may well have applied every\n    // entry, and a creation re-sent for an entity it already holds is refused -- a trail kept\n    // pending on a guess would come back to that refusal cycle after cycle. The line moves only\n    // where the Kernel itself named the count.\n    const appliedCount = reason instanceof ChangeTrailRefusedError ? reason.appliedCount : changeTrail.length;\n\n    // `?.` rather than `!`: the view can be taken off -- `env.view = undefined` -- between the\n    // await above and this line\n    this.view?.commitChangeTrail(appliedCount, changeTrail);\n  }\n\n  /**\n   * Sends one of the two context events and keeps a listener that throws to itself.\n   *\n   * Both go out from inside the effect that watches `viewReady` and `proxyReady` -- `ContextLost`\n   * from its cleanup -- so a throw would leave through whatever signal write set that effect\n   * going, and reach code that has nothing to do with either event. `emitStrict()` serves every\n   * listener whatever the one before it did, and what they threw is reported here and travels no\n   * further.\n   */\n  #announceContext(eventName: string, self: ShadowEnv): void {\n    try {\n      emitStrict(self, eventName, self);\n    } catch (error) {\n      this.logger.error(`a ${eventName} listener threw`, error);\n    }\n  }\n\n  /**\n   * Ends a synchronization cycle in exactly one of its two outcomes. A cycle the Shadow\n   * Environment applied resolves {@link ShadowEnv.syncWait} and emits {@link ShadowEnv.AfterSync};\n   * a cycle whose change trail it refused rejects and emits {@link ShadowEnv.SyncFailed}. Only a\n   * listener that can tell the two apart can react to either, so no cycle ever sends both.\n   *\n   * The waiting caller is settled before the event goes out, and the emit is the last thing that\n   * happens: a settlement that travelled as a listener of its own would sit behind whatever the\n   * application registered during setup, and this method is the wrong place to make a promise\n   * depend on the order consumers subscribe in. The dispatch is `emitStrict()`, so every listener\n   * hears about the cycle whatever the one before it did, and what they threw arrives here\n   * afterwards -- one of them unchanged, several as an `AggregateError` in dispatch order. It ends\n   * here as well: `#syncNow()` runs unawaited, and an error escaping it becomes an unhandled\n   * rejection rather than a report anybody reads.\n   *\n   * Which cycle is being ended arrives as an argument: the caller carries it from the moment its\n   * change trail was built, so a cycle that is still in flight cannot be settled by the one behind it.\n   */\n  #endSyncCycle(changeTrail: ChangeTrailType, cycle: SyncCycle | undefined, failure?: {reason: unknown}) {\n    try {\n      if (failure) {\n        cycle?.reject(failure.reason);\n        emitStrict(this as ShadowEnv, ShadowEnv.SyncFailed, failure.reason, changeTrail, this as ShadowEnv);\n      } else {\n        cycle?.resolve(changeTrail);\n        emitStrict(this as ShadowEnv, ShadowEnv.AfterSync, changeTrail);\n      }\n    } catch (error) {\n      this.logger.error('a sync cycle listener threw', error);\n    }\n  }\n\n  #onMessageToView(event: Omit<MessageToViewEvent, 'transferables'>) {\n    this.logger.debug('onMessageToView', event.type, event.data);\n    this.view?.dispatchMessage(event.uuid, event.type, event.data, event.traverseChildren);\n  }\n\n  #onProxyFailed(reason: unknown) {\n    // destroy() freezes this instance and destroys its signals; a proxy may report its failure afterwards\n    if (this.#isDestroyed) return;\n\n    this.logger.error('the environment proxy failed', reason);\n\n    // the failure ends this proxy's turn the same way a reassignment would: a start of its own\n    // that resolves afterwards must not report a lost environment as ready\n    ++this.#proxyGeneration;\n\n    try {\n      // the reason before the consequence: ContextLost follows from dropping proxyReady.\n      // `emitStrict()` so that one listener that cannot cope does not keep the rest from hearing\n      // that the environment is gone; what it threw travels on to the proxy that reported the\n      // failure, which is where this method has always put it.\n      emitStrict(this as ShadowEnv, ShadowEnv.ProxyFailed, reason, this as ShadowEnv);\n    } finally {\n      // in the `finally`, because losing the environment is not up for debate:\n      // a listener that throws must not leave `isReady` claiming otherwise\n      this.proxyReady = false;\n    }\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }