@spearwolf/shadow-objects 0.33.0 → 0.35.0

package/src/elements/constants.js

@@ -1,33 +1,51 @@
 const RequestEntParentEventName = "shaeRequestEntParent";
 const ReRequestEntParentEventName = "shaeReRequestEntParent";
+const ReRequestEntHostEventName = "shaeReRequestEntHost";
 const SHAE_WORKER = "shae-worker";
 const SHAE_ENT = "shae-ent";
 const SHAE_PROP = "shae-prop";
 const ATTR_TOKEN = "token";
 const ATTR_FORWARD_CUSTOM_EVENTS = "forward-custom-events";
+const ATTR_AUTO_DESTRUCT = "auto-destruct";
 const ATTR_NS = "ns";
 const ATTR_LOCAL = "local";
 const ATTR_NO_AUTOSTART = "no-autostart";
 const ATTR_NO_STRUCTURED_CLONE = "no-structured-clone";
 const ATTR_AUTO_SYNC = "auto-sync";
 const ATTR_SRC = "src";
+const ATTR_LOAD_TIMEOUT = "load-timeout";
+const ATTR_CONFIGURE_TIMEOUT = "configure-timeout";
+const ATTR_CHANGE_TRAIL_TIMEOUT = "change-trail-timeout";
+const ATTR_INSPECT_TIMEOUT = "inspect-timeout";
+const ATTR_DESTROY_TIMEOUT = "destroy-timeout";
+const ATTR_EXPOSE_TO_MODEL_CONTEXT = "expose-to-model-context";
+const ATTR_REDACT_PROPS = "redact-props";
 const ATTR_NAME = "name";
 const ATTR_VALUE = "value";
 const ATTR_TYPE = "type";
 const ATTR_NO_TRIM = "no-trim";
 export {
+  ATTR_AUTO_DESTRUCT,
   ATTR_AUTO_SYNC,
+  ATTR_CHANGE_TRAIL_TIMEOUT,
+  ATTR_CONFIGURE_TIMEOUT,
+  ATTR_DESTROY_TIMEOUT,
+  ATTR_EXPOSE_TO_MODEL_CONTEXT,
   ATTR_FORWARD_CUSTOM_EVENTS,
+  ATTR_INSPECT_TIMEOUT,
+  ATTR_LOAD_TIMEOUT,
   ATTR_LOCAL,
   ATTR_NAME,
   ATTR_NO_AUTOSTART,
   ATTR_NO_STRUCTURED_CLONE,
   ATTR_NO_TRIM,
   ATTR_NS,
+  ATTR_REDACT_PROPS,
   ATTR_SRC,
   ATTR_TOKEN,
   ATTR_TYPE,
   ATTR_VALUE,
+  ReRequestEntHostEventName,
   ReRequestEntParentEventName,
   RequestEntParentEventName,
   SHAE_ENT,

package/src/elements/constants.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/elements/constants.ts"],
-  "sourcesContent": ["export const RequestEntParentEventName = 'shaeRequestEntParent';\nexport const ReRequestEntParentEventName = 'shaeReRequestEntParent';\n\nexport const SHAE_WORKER = 'shae-worker';\nexport const SHAE_ENT = 'shae-ent';\nexport const SHAE_PROP = 'shae-prop';\n\n// <shae-ent> attributes\nexport const ATTR_TOKEN = 'token';\nexport const ATTR_FORWARD_CUSTOM_EVENTS = 'forward-custom-events';\n\n// <shae-ent> + <shae-worker> attributes\nexport const ATTR_NS = 'ns';\n\n// <shae-worker> attributes\nexport const ATTR_LOCAL = 'local';\nexport const ATTR_NO_AUTOSTART = 'no-autostart';\nexport const ATTR_NO_STRUCTURED_CLONE = 'no-structured-clone';\nexport const ATTR_AUTO_SYNC = 'auto-sync';\nexport const ATTR_SRC = 'src';\n\n// <shae-prop> attributes\nexport const ATTR_NAME = 'name';\nexport const ATTR_VALUE = 'value';\nexport const ATTR_TYPE = 'type';\nexport const ATTR_NO_TRIM = 'no-trim';"],
-  "mappings": "AAAO,MAAM,4BAA4B;AAClC,MAAM,8BAA8B;AAEpC,MAAM,cAAc;AACpB,MAAM,WAAW;AACjB,MAAM,YAAY;AAGlB,MAAM,aAAa;AACnB,MAAM,6BAA6B;AAGnC,MAAM,UAAU;AAGhB,MAAM,aAAa;AACnB,MAAM,oBAAoB;AAC1B,MAAM,2BAA2B;AACjC,MAAM,iBAAiB;AACvB,MAAM,WAAW;AAGjB,MAAM,YAAY;AAClB,MAAM,aAAa;AACnB,MAAM,YAAY;AAClB,MAAM,eAAe;",
+  "sourcesContent": ["export const RequestEntParentEventName = 'shaeRequestEntParent';\nexport const ReRequestEntParentEventName = 'shaeReRequestEntParent';\nexport const ReRequestEntHostEventName = 'shaeReRequestEntHost';\n\nexport const SHAE_WORKER = 'shae-worker';\nexport const SHAE_ENT = 'shae-ent';\nexport const SHAE_PROP = 'shae-prop';\n\n// <shae-ent> attributes\nexport const ATTR_TOKEN = 'token';\nexport const ATTR_FORWARD_CUSTOM_EVENTS = 'forward-custom-events';\nexport const ATTR_AUTO_DESTRUCT = 'auto-destruct';\n\n// <shae-ent> + <shae-worker> attributes\nexport const ATTR_NS = 'ns';\n\n// <shae-worker> attributes\nexport const ATTR_LOCAL = 'local';\nexport const ATTR_NO_AUTOSTART = 'no-autostart';\nexport const ATTR_NO_STRUCTURED_CLONE = 'no-structured-clone';\nexport const ATTR_AUTO_SYNC = 'auto-sync';\nexport const ATTR_SRC = 'src';\nexport const ATTR_LOAD_TIMEOUT = 'load-timeout';\nexport const ATTR_CONFIGURE_TIMEOUT = 'configure-timeout';\nexport const ATTR_CHANGE_TRAIL_TIMEOUT = 'change-trail-timeout';\nexport const ATTR_INSPECT_TIMEOUT = 'inspect-timeout';\nexport const ATTR_DESTROY_TIMEOUT = 'destroy-timeout';\nexport const ATTR_EXPOSE_TO_MODEL_CONTEXT = 'expose-to-model-context';\nexport const ATTR_REDACT_PROPS = 'redact-props';\n\n// <shae-prop> attributes\nexport const ATTR_NAME = 'name';\nexport const ATTR_VALUE = 'value';\nexport const ATTR_TYPE = 'type';\nexport const ATTR_NO_TRIM = 'no-trim';\n"],
+  "mappings": "AAAO,MAAM,4BAA4B;AAClC,MAAM,8BAA8B;AACpC,MAAM,4BAA4B;AAElC,MAAM,cAAc;AACpB,MAAM,WAAW;AACjB,MAAM,YAAY;AAGlB,MAAM,aAAa;AACnB,MAAM,6BAA6B;AACnC,MAAM,qBAAqB;AAG3B,MAAM,UAAU;AAGhB,MAAM,aAAa;AACnB,MAAM,oBAAoB;AAC1B,MAAM,2BAA2B;AACjC,MAAM,iBAAiB;AACvB,MAAM,WAAW;AACjB,MAAM,oBAAoB;AAC1B,MAAM,yBAAyB;AAC/B,MAAM,4BAA4B;AAClC,MAAM,uBAAuB;AAC7B,MAAM,uBAAuB;AAC7B,MAAM,+BAA+B;AACrC,MAAM,oBAAoB;AAG1B,MAAM,YAAY;AAClB,MAAM,aAAa;AACnB,MAAM,YAAY;AAClB,MAAM,eAAe;",
   "names": []
 }

package/src/elements/deferredTeardown.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A teardown that waits for the next microtask before it commits.
+ *
+ * Leaving the tree is not the same as ending. A re-render takes an element out and puts it back
+ * inside one task, and everything hanging on it — an environment, its proxy, every entity in it —
+ * has to come through that move untouched. So the teardown is booked instead of run, and the
+ * microtask that follows asks where the element stands by then: whoever moved it in the meantime
+ * has left the answer here, and being back in the tree calls the teardown off. However often the
+ * element is moved inside that one window, only the first booking queues a microtask, so the
+ * question is asked once. An element that is still out when the microtask runs is torn down.
+ *
+ * A cancelled booking leaves its microtask standing — it wakes up, finds nothing booked and
+ * returns. Running twice is not guarded against here: that guard belongs to the teardown itself,
+ * which is callable by hand as well and has to carry it in either case.
+ */
+export declare class DeferredTeardown {
+    #private;
+    constructor(run: () => void);
+    /** Book the teardown, and make sure someone comes asking. */
+    schedule(): void;
+    /** Take the booking back. */
+    cancel(): void;
+}
+//# sourceMappingURL=deferredTeardown.d.ts.map

package/src/elements/deferredTeardown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferredTeardown.d.ts","sourceRoot":"","sources":["../../../src/elements/deferredTeardown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAgB;;IAS3B,YAAY,GAAG,EAAE,MAAM,IAAI,EAE1B;IAED,6DAA6D;IAC7D,QAAQ,IAAI,IAAI,CAgBf;IAED,6BAA6B;IAC7B,MAAM,IAAI,IAAI,CAEb;CACF"}

package/src/elements/deferredTeardown.js

@@ -0,0 +1,30 @@
+class DeferredTeardown {
+  #run;
+  /** Whether a teardown is booked right now. */
+  #isBooked = false;
+  /** Whether a microtask is already on its way to ask. */
+  #isAsking = false;
+  constructor(run) {
+    this.#run = run;
+  }
+  /** Book the teardown, and make sure someone comes asking. */
+  schedule() {
+    this.#isBooked = true;
+    if (this.#isAsking) return;
+    this.#isAsking = true;
+    queueMicrotask(() => {
+      this.#isAsking = false;
+      if (!this.#isBooked) return;
+      this.#isBooked = false;
+      this.#run();
+    });
+  }
+  /** Take the booking back. */
+  cancel() {
+    this.#isBooked = false;
+  }
+}
+export {
+  DeferredTeardown
+};
+//# sourceMappingURL=deferredTeardown.js.map

package/src/elements/deferredTeardown.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/elements/deferredTeardown.ts"],
+  "sourcesContent": ["/**\n * A teardown that waits for the next microtask before it commits.\n *\n * Leaving the tree is not the same as ending. A re-render takes an element out and puts it back\n * inside one task, and everything hanging on it \u2014 an environment, its proxy, every entity in it \u2014\n * has to come through that move untouched. So the teardown is booked instead of run, and the\n * microtask that follows asks where the element stands by then: whoever moved it in the meantime\n * has left the answer here, and being back in the tree calls the teardown off. However often the\n * element is moved inside that one window, only the first booking queues a microtask, so the\n * question is asked once. An element that is still out when the microtask runs is torn down.\n *\n * A cancelled booking leaves its microtask standing \u2014 it wakes up, finds nothing booked and\n * returns. Running twice is not guarded against here: that guard belongs to the teardown itself,\n * which is callable by hand as well and has to carry it in either case.\n */\nexport class DeferredTeardown {\n  readonly #run: () => void;\n\n  /** Whether a teardown is booked right now. */\n  #isBooked = false;\n\n  /** Whether a microtask is already on its way to ask. */\n  #isAsking = false;\n\n  constructor(run: () => void) {\n    this.#run = run;\n  }\n\n  /** Book the teardown, and make sure someone comes asking. */\n  schedule(): void {\n    this.#isBooked = true;\n\n    if (this.#isAsking) return;\n    this.#isAsking = true;\n\n    queueMicrotask(() => {\n      this.#isAsking = false;\n      if (!this.#isBooked) return;\n      // the booking is cleared in front of the run, not behind it: the field says whether a\n      // teardown is waiting, and one that is being carried out is not waiting. It also decides what\n      // a `schedule()` from inside the teardown means \u2014 a fresh round, rather than a booking that\n      // the line behind the call would wipe out\n      this.#isBooked = false;\n      this.#run();\n    });\n  }\n\n  /** Take the booking back. */\n  cancel(): void {\n    this.#isBooked = false;\n  }\n}\n"],
+  "mappings": "AAeO,MAAM,iBAAiB;AAAA,EACnB;AAAA;AAAA,EAGT,YAAY;AAAA;AAAA,EAGZ,YAAY;AAAA,EAEZ,YAAY,KAAiB;AAC3B,SAAK,OAAO;AAAA,EACd;AAAA;AAAA,EAGA,WAAiB;AACf,SAAK,YAAY;AAEjB,QAAI,KAAK,UAAW;AACpB,SAAK,YAAY;AAEjB,mBAAe,MAAM;AACnB,WAAK,YAAY;AACjB,UAAI,CAAC,KAAK,UAAW;AAKrB,WAAK,YAAY;AACjB,WAAK,KAAK;AAAA,IACZ,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,SAAe;AACb,SAAK,YAAY;AAAA,EACnB;AACF;",
+  "names": []
+}

package/src/elements/displayContentsRule.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Makes sure `root` carries a `display: contents` rule for `tagName`, and does so once per root.
+ *
+ * The elements of this library carry no box of their own: they wire DOM structure into entities
+ * and must leave the layout of whatever sits inside them untouched. That is a styling statement,
+ * and a stylesheet rule is where it belongs — an element constructor cannot make it, because the
+ * Custom Elements specification forbids a constructor from giving its element attributes, and an
+ * inline style is written as the `style` attribute. A constructor that writes one makes the
+ * browser abort the upgrade and hand back an `HTMLUnknownElement`.
+ *
+ * The rule is keyed by the tag name the element actually connects under, not by a fixed list:
+ * a subclass registered under a tag of its own — the extension point the guides describe — lays
+ * out no box either, and is covered the moment one of its instances connects. A tag that joins
+ * later widens the selector of the rule already there instead of adding a second one, so the
+ * position of the rule in the cascade never moves.
+ *
+ * The rule goes to the root the element stands in, not to `document`: style rules do not cross a
+ * shadow boundary, so an element inside a shadow root needs the rule inside that root.
+ *
+ * It is prepended rather than appended. Its specificity is 0-0-1, so a rule of the consumer's with
+ * the same specificity decides by order — coming later, it wins, and nobody needs `!important` to
+ * override the default.
+ */
+export declare const ensureDisplayContentsRule: (root: Node, tagName: string) => void;
+//# sourceMappingURL=displayContentsRule.d.ts.map

package/src/elements/displayContentsRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"displayContentsRule.d.ts","sourceRoot":"","sources":["../../../src/elements/displayContentsRule.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,yBAAyB,SAAU,IAAI,WAAW,MAAM,KAAG,IAyCvE,CAAC"}

package/src/elements/displayContentsRule.js

@@ -0,0 +1,37 @@
+const RuleStatePerRoot = /* @__PURE__ */ new WeakMap();
+const buildRule = (tags) => `${Array.from(tags, (tag) => CSS.escape(tag)).join(",")}{display:contents}`;
+const isDocument = (node) => node.nodeType === 9;
+const isShadowRoot = (node) => node.nodeType === 11 && node.host != null;
+const ensureDisplayContentsRule = (root, tagName) => {
+  let mountPoint;
+  let doc;
+  let key;
+  if (isDocument(root)) {
+    mountPoint = root.head ?? root.documentElement ?? root;
+    doc = root;
+    key = root;
+  } else if (isShadowRoot(root)) {
+    mountPoint = root;
+    doc = root.ownerDocument;
+    key = root;
+  } else {
+    return;
+  }
+  const state = RuleStatePerRoot.get(key);
+  if (state?.style.isConnected) {
+    if (state.tags.has(tagName)) return;
+    state.tags.add(tagName);
+    state.style.textContent = buildRule(state.tags);
+    return;
+  }
+  const tags = state?.tags ?? /* @__PURE__ */ new Set();
+  tags.add(tagName);
+  const style = doc.createElement("style");
+  style.textContent = buildRule(tags);
+  mountPoint.prepend(style);
+  RuleStatePerRoot.set(key, { tags, style });
+};
+export {
+  ensureDisplayContentsRule
+};
+//# sourceMappingURL=displayContentsRule.js.map

package/src/elements/displayContentsRule.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/elements/displayContentsRule.ts"],
+  "sourcesContent": ["/** What a root already carries: the tag names covered, and the element holding the rule. */\ninterface DisplayRuleState {\n  tags: Set<string>;\n  style: HTMLStyleElement;\n}\n\nconst RuleStatePerRoot = new WeakMap<Document | ShadowRoot, DisplayRuleState>();\n\n// `CSS.escape` guards a tag name that carries a character the selector grammar would otherwise\n// read as a combinator \u2014 a dot is legal in a custom element name and would parse as a class\n// selector instead of naming the tag it belongs to\nconst buildRule = (tags: Set<string>): string => `${Array.from(tags, (tag) => CSS.escape(tag)).join(',')}{display:contents}`;\n\n/**\n * Whether `node` is a document \u2014 across realms.\n *\n * `instanceof Document` reads the constructor of the realm this module was loaded in, so an\n * element adopted into a document from another realm \u2014 an iframe, most of all \u2014 would fall\n * through it and quietly get no rule at all. The node type is the same number everywhere.\n */\nconst isDocument = (node: Node): node is Document => node.nodeType === 9;\n\n/** Whether `node` is a shadow root, by the same reasoning \u2014 a document fragment carrying a host. */\nconst isShadowRoot = (node: Node): node is ShadowRoot => node.nodeType === 11 && (node as ShadowRoot).host != null;\n\n/**\n * Makes sure `root` carries a `display: contents` rule for `tagName`, and does so once per root.\n *\n * The elements of this library carry no box of their own: they wire DOM structure into entities\n * and must leave the layout of whatever sits inside them untouched. That is a styling statement,\n * and a stylesheet rule is where it belongs \u2014 an element constructor cannot make it, because the\n * Custom Elements specification forbids a constructor from giving its element attributes, and an\n * inline style is written as the `style` attribute. A constructor that writes one makes the\n * browser abort the upgrade and hand back an `HTMLUnknownElement`.\n *\n * The rule is keyed by the tag name the element actually connects under, not by a fixed list:\n * a subclass registered under a tag of its own \u2014 the extension point the guides describe \u2014 lays\n * out no box either, and is covered the moment one of its instances connects. A tag that joins\n * later widens the selector of the rule already there instead of adding a second one, so the\n * position of the rule in the cascade never moves.\n *\n * The rule goes to the root the element stands in, not to `document`: style rules do not cross a\n * shadow boundary, so an element inside a shadow root needs the rule inside that root.\n *\n * It is prepended rather than appended. Its specificity is 0-0-1, so a rule of the consumer's with\n * the same specificity decides by order \u2014 coming later, it wins, and nobody needs `!important` to\n * override the default.\n */\nexport const ensureDisplayContentsRule = (root: Node, tagName: string): void => {\n  let mountPoint: ParentNode;\n  let doc: Document;\n  let key: Document | ShadowRoot;\n\n  if (isDocument(root)) {\n    // `head` is typed non-null but a document can be built without one \u2014 an XML document, or a\n    // `createDocument()` \u2014 so the rule falls back to whatever parent the document offers\n    mountPoint = root.head ?? root.documentElement ?? root;\n    doc = root;\n    key = root;\n  } else if (isShadowRoot(root)) {\n    mountPoint = root;\n    doc = root.ownerDocument;\n    key = root;\n  } else {\n    // an element that has entered neither a document nor a shadow root is its own root: nothing\n    // to style yet, and the next connect asks again\n    return;\n  }\n\n  const state = RuleStatePerRoot.get(key);\n\n  // a root that gets its content replaced wholesale \u2014 a shadow root re-filled through `innerHTML`,\n  // most of all \u2014 takes the `<style>` the rule lives in down with the rest of the markup, so the\n  // root can look known while the element carrying its rule is no longer in it. Rebuilding the\n  // `<style>` here covers both a root seen for the first time and one whose rule element fell out.\n  if (state?.style.isConnected) {\n    if (state.tags.has(tagName)) return;\n    state.tags.add(tagName);\n    state.style.textContent = buildRule(state.tags);\n    return;\n  }\n\n  const tags = state?.tags ?? new Set();\n  tags.add(tagName);\n  const style = doc.createElement('style');\n  style.textContent = buildRule(tags);\n  mountPoint.prepend(style);\n\n  RuleStatePerRoot.set(key, {tags, style});\n};\n"],
+  "mappings": "AAMA,MAAM,mBAAmB,oBAAI,QAAiD;AAK9E,MAAM,YAAY,CAAC,SAA8B,GAAG,MAAM,KAAK,MAAM,CAAC,QAAQ,IAAI,OAAO,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC;AASxG,MAAM,aAAa,CAAC,SAAiC,KAAK,aAAa;AAGvE,MAAM,eAAe,CAAC,SAAmC,KAAK,aAAa,MAAO,KAAoB,QAAQ;AAyBvG,MAAM,4BAA4B,CAAC,MAAY,YAA0B;AAC9E,MAAI;AACJ,MAAI;AACJ,MAAI;AAEJ,MAAI,WAAW,IAAI,GAAG;AAGpB,iBAAa,KAAK,QAAQ,KAAK,mBAAmB;AAClD,UAAM;AACN,UAAM;AAAA,EACR,WAAW,aAAa,IAAI,GAAG;AAC7B,iBAAa;AACb,UAAM,KAAK;AACX,UAAM;AAAA,EACR,OAAO;AAGL;AAAA,EACF;AAEA,QAAM,QAAQ,iBAAiB,IAAI,GAAG;AAMtC,MAAI,OAAO,MAAM,aAAa;AAC5B,QAAI,MAAM,KAAK,IAAI,OAAO,EAAG;AAC7B,UAAM,KAAK,IAAI,OAAO;AACtB,UAAM,MAAM,cAAc,UAAU,MAAM,IAAI;AAC9C;AAAA,EACF;AAEA,QAAM,OAAO,OAAO,QAAQ,oBAAI,IAAI;AACpC,OAAK,IAAI,OAAO;AAChB,QAAM,QAAQ,IAAI,cAAc,OAAO;AACvC,QAAM,cAAc,UAAU,IAAI;AAClC,aAAW,QAAQ,KAAK;AAExB,mBAAiB,IAAI,KAAK,EAAC,MAAM,MAAK,CAAC;AACzC;",
+  "names": []
+}

package/src/elements/events.d.ts

@@ -1,24 +1,27 @@
-import type { RequestEntParentEventName, ReRequestEntParentEventName } from './constants.js';
+import type { RequestEntParentEventName, ReRequestEntHostEventName, ReRequestEntParentEventName } from './constants.js';
+import type { EntAncestorRequest } from './requestEntAncestor.js';
 import type { ShaeEntElement } from './ShaeEntElement.js';
 export interface RequestEntParentEvent extends CustomEvent {
+    detail: EntAncestorRequest;
+}
+export interface ReRequestEntParentEvent extends CustomEvent {
     detail: {
         requester: ShaeEntElement;
+        shadowRootHost: HTMLElement;
     };
 }
-export interface ReRequestEntParentEvent extends CustomEvent {
+export interface ReRequestEntHostEvent extends CustomEvent {
     detail: {
         requester: ShaeEntElement;
-        shadowRootHost: HTMLElement;
     };
 }
-export interface ShadowEntsEventMap {
+export interface ShadowObjectsEventMap {
     [RequestEntParentEventName]: RequestEntParentEvent;
     [ReRequestEntParentEventName]: ReRequestEntParentEvent;
+    [ReRequestEntHostEventName]: ReRequestEntHostEvent;
 }
 declare global {
-    interface HTMLElementEventMap extends ShadowEntsEventMap {
-        addEventListener<K extends keyof ShadowEntsEventMap>(type: K, listener: (this: Document, ev: ShadowEntsEventMap[K]) => void): void;
-        dispatchEvent<K extends keyof ShadowEntsEventMap>(ev: ShadowEntsEventMap[K]): void;
+    interface HTMLElementEventMap extends ShadowObjectsEventMap {
     }
 }
 //# sourceMappingURL=events.d.ts.map

package/src/elements/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/elements/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,yBAAyB,EAAE,2BAA2B,EAAC,MAAM,gBAAgB,CAAC;AAC3F,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAExD,MAAM,WAAW,qBAAsB,SAAQ,WAAW;IACxD,MAAM,EAAE;QACN,SAAS,EAAE,cAAc,CAAC;KAC3B,CAAC;CACH;AAED,MAAM,WAAW,uBAAwB,SAAQ,WAAW;IAC1D,MAAM,EAAE;QACN,SAAS,EAAE,cAAc,CAAC;QAC1B,cAAc,EAAE,WAAW,CAAC;KAC7B,CAAC;CACH;AAED,MAAM,WAAW,kBAAkB;IACjC,CAAC,yBAAyB,CAAC,EAAE,qBAAqB,CAAC;IACnD,CAAC,2BAA2B,CAAC,EAAE,uBAAuB,CAAC;CACxD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,mBAAoB,SAAQ,kBAAkB;QACtD,gBAAgB,CAAC,CAAC,SAAS,MAAM,kBAAkB,EACjD,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,kBAAkB,CAAC,CAAC,CAAC,KAAK,IAAI,GAC5D,IAAI,CAAC;QACR,aAAa,CAAC,CAAC,SAAS,MAAM,kBAAkB,EAAE,EAAE,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;KACpF;CACF"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/elements/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,yBAAyB,EAAE,yBAAyB,EAAE,2BAA2B,EAAC,MAAM,gBAAgB,CAAC;AACtH,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAExD,MAAM,WAAW,qBAAsB,SAAQ,WAAW;IACxD,MAAM,EAAE,kBAAkB,CAAC;CAC5B;AAED,MAAM,WAAW,uBAAwB,SAAQ,WAAW;IAC1D,MAAM,EAAE;QACN,SAAS,EAAE,cAAc,CAAC;QAC1B,cAAc,EAAE,WAAW,CAAC;KAC7B,CAAC;CACH;AAED,MAAM,WAAW,qBAAsB,SAAQ,WAAW;IACxD,MAAM,EAAE;QACN,SAAS,EAAE,cAAc,CAAC;KAC3B,CAAC;CACH;AAED,MAAM,WAAW,qBAAqB;IACpC,CAAC,yBAAyB,CAAC,EAAE,qBAAqB,CAAC;IACnD,CAAC,2BAA2B,CAAC,EAAE,uBAAuB,CAAC;IACvD,CAAC,yBAAyB,CAAC,EAAE,qBAAqB,CAAC;CACpD;AAED,OAAO,CAAC,MAAM,CAAC;IAGb,UAAU,mBAAoB,SAAQ,qBAAqB;KAAG;CAC/D"}

package/src/elements/forwardCustomEvents.d.ts

@@ -0,0 +1,19 @@
+import type { ViewComponent } from '../view/ViewComponent.js';
+/** An allow-list without entries forwards nothing — the same thing `false` says. */
+export declare const isEmptyFilter: (val: Set<string> | boolean) => boolean;
+/**
+ * Whether two filter values are the same value — a `Set` by its entries rather than by identity.
+ *
+ * This is not the question {@link isEmptyFilter} answers. An empty `Set` and `false` forward the
+ * same nothing, and they are still two different values: only a write that replaces the one with
+ * the other reaches the subscribers of the signal, and the read-back on connect depends on it.
+ */
+export declare const isSameFilter: (a: Set<string> | boolean, b: Set<string> | boolean) => boolean;
+/**
+ * Carry the events a component dispatches out to `target` as DOM events, as far as `filter` allows.
+ *
+ * Answers with the call that takes the forwarding back, or with `undefined` where `filter` forwards
+ * nothing and no patch was set.
+ */
+export declare const forwardCustomEventsFrom: (vc: ViewComponent, target: EventTarget, filter: Set<string> | boolean) => (() => void) | undefined;
+//# sourceMappingURL=forwardCustomEvents.d.ts.map

package/src/elements/forwardCustomEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwardCustomEvents.d.ts","sourceRoot":"","sources":["../../../src/elements/forwardCustomEvents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,oFAAoF;AACpF,eAAO,MAAM,aAAa,QAAS,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,KAAG,OAA+C,CAAC;AAE3G;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,MAAO,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,KAAK,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,KAAG,OAUjF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,OAC9B,aAAa,UACT,WAAW,UACX,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,KAC5B,CAAC,MAAM,IAAI,CAAC,GAAG,SA+CjB,CAAC"}

package/src/elements/forwardCustomEvents.js

@@ -0,0 +1,47 @@
+import { ComponentContext } from "../view/ComponentContext.js";
+const isEmptyFilter = (val) => val instanceof Set && val.size === 0;
+const isSameFilter = (a, b) => {
+  if (a === b) return true;
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const type of a) {
+      if (!b.has(type)) return false;
+    }
+    return true;
+  }
+  return false;
+};
+const forwardCustomEventsFrom = (vc, target, filter) => {
+  if (!filter || isEmptyFilter(filter)) return;
+  const originalDispatchEvent = Object.hasOwn(vc, "dispatchEvent") ? Object.getPrototypeOf(vc).dispatchEvent : vc.dispatchEvent;
+  const allowedTypes = filter instanceof Set ? filter : void 0;
+  const newDispatch = (type, data, traverseChildren) => {
+    originalDispatchEvent.call(vc, type, data, traverseChildren);
+    if (type === ComponentContext.ReRequestParentRoots || type === ComponentContext.ReRequestParent || type === ComponentContext.ReRequestEntHost)
+      return;
+    if (allowedTypes && !allowedTypes.has(type)) return;
+    target.dispatchEvent(
+      new CustomEvent(type, {
+        bubbles: true,
+        composed: true,
+        detail: data
+      })
+    );
+  };
+  Object.defineProperty(vc, "dispatchEvent", {
+    value: newDispatch,
+    writable: true,
+    configurable: true
+  });
+  return () => {
+    if (Object.hasOwn(vc, "dispatchEvent") && vc.dispatchEvent === newDispatch) {
+      delete vc.dispatchEvent;
+    }
+  };
+};
+export {
+  forwardCustomEventsFrom,
+  isEmptyFilter,
+  isSameFilter
+};
+//# sourceMappingURL=forwardCustomEvents.js.map

package/src/elements/forwardCustomEvents.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/elements/forwardCustomEvents.ts"],
+  "sourcesContent": ["import {ComponentContext} from '../view/ComponentContext.js';\nimport type {ViewComponent} from '../view/ViewComponent.js';\n\n/** An allow-list without entries forwards nothing \u2014 the same thing `false` says. */\nexport const isEmptyFilter = (val: Set<string> | boolean): boolean => val instanceof Set && val.size === 0;\n\n/**\n * Whether two filter values are the same value \u2014 a `Set` by its entries rather than by identity.\n *\n * This is not the question {@link isEmptyFilter} answers. An empty `Set` and `false` forward the\n * same nothing, and they are still two different values: only a write that replaces the one with\n * the other reaches the subscribers of the signal, and the read-back on connect depends on it.\n */\nexport const isSameFilter = (a: Set<string> | boolean, b: Set<string> | boolean): boolean => {\n  if (a === b) return true;\n  if (a instanceof Set && b instanceof Set) {\n    if (a.size !== b.size) return false;\n    for (const type of a) {\n      if (!b.has(type)) return false;\n    }\n    return true;\n  }\n  return false;\n};\n\n/**\n * Carry the events a component dispatches out to `target` as DOM events, as far as `filter` allows.\n *\n * Answers with the call that takes the forwarding back, or with `undefined` where `filter` forwards\n * nothing and no patch was set.\n */\nexport const forwardCustomEventsFrom = (\n  vc: ViewComponent,\n  target: EventTarget,\n  filter: Set<string> | boolean,\n): (() => void) | undefined => {\n  if (!filter || isEmptyFilter(filter)) return;\n\n  // the patch goes on the instance, so a component that already carries one shadows the very\n  // method the new patch has to call through to: that original sits on the prototype\n  const originalDispatchEvent = Object.hasOwn(vc, 'dispatchEvent') ? Object.getPrototypeOf(vc).dispatchEvent : vc.dispatchEvent;\n\n  const allowedTypes = filter instanceof Set ? filter : undefined;\n\n  const newDispatch = (type: string, data: unknown, traverseChildren: boolean) => {\n    originalDispatchEvent.call(vc, type, data, traverseChildren);\n\n    // the internal signals of the parent resolution never leave the view side as a DOM event,\n    // not even under `forward-custom-events` without a filter list\n    if (\n      type === ComponentContext.ReRequestParentRoots ||\n      type === ComponentContext.ReRequestParent ||\n      type === ComponentContext.ReRequestEntHost\n    )\n      return;\n\n    if (allowedTypes && !allowedTypes.has(type)) return;\n\n    target.dispatchEvent(\n      new CustomEvent(type, {\n        bubbles: true,\n        composed: true,\n        detail: data,\n      }),\n    );\n  };\n\n  // We use defineProperty to ensure it is writable and configurable\n  Object.defineProperty(vc, 'dispatchEvent', {\n    value: newDispatch,\n    writable: true,\n    configurable: true,\n  });\n\n  return () => {\n    if (Object.hasOwn(vc, 'dispatchEvent') && vc.dispatchEvent === newDispatch) {\n      // the property lives on the instance (defineProperty above), the method it shadows lives\n      // on the prototype: deleting the own property restores the original, it does not remove\n      // the method\n      delete (vc as {dispatchEvent?: ViewComponent['dispatchEvent']}).dispatchEvent;\n    }\n  };\n};\n"],
+  "mappings": "AAAA,SAAQ,wBAAuB;AAIxB,MAAM,gBAAgB,CAAC,QAAwC,eAAe,OAAO,IAAI,SAAS;AASlG,MAAM,eAAe,CAAC,GAA0B,MAAsC;AAC3F,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,aAAa,OAAO,aAAa,KAAK;AACxC,QAAI,EAAE,SAAS,EAAE,KAAM,QAAO;AAC9B,eAAW,QAAQ,GAAG;AACpB,UAAI,CAAC,EAAE,IAAI,IAAI,EAAG,QAAO;AAAA,IAC3B;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAQO,MAAM,0BAA0B,CACrC,IACA,QACA,WAC6B;AAC7B,MAAI,CAAC,UAAU,cAAc,MAAM,EAAG;AAItC,QAAM,wBAAwB,OAAO,OAAO,IAAI,eAAe,IAAI,OAAO,eAAe,EAAE,EAAE,gBAAgB,GAAG;AAEhH,QAAM,eAAe,kBAAkB,MAAM,SAAS;AAEtD,QAAM,cAAc,CAAC,MAAc,MAAe,qBAA8B;AAC9E,0BAAsB,KAAK,IAAI,MAAM,MAAM,gBAAgB;AAI3D,QACE,SAAS,iBAAiB,wBAC1B,SAAS,iBAAiB,mBAC1B,SAAS,iBAAiB;AAE1B;AAEF,QAAI,gBAAgB,CAAC,aAAa,IAAI,IAAI,EAAG;AAE7C,WAAO;AAAA,MACL,IAAI,YAAY,MAAM;AAAA,QACpB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,QAAQ;AAAA,MACV,CAAC;AAAA,IACH;AAAA,EACF;AAGA,SAAO,eAAe,IAAI,iBAAiB;AAAA,IACzC,OAAO;AAAA,IACP,UAAU;AAAA,IACV,cAAc;AAAA,EAChB,CAAC;AAED,SAAO,MAAM;AACX,QAAI,OAAO,OAAO,IAAI,eAAe,KAAK,GAAG,kBAAkB,aAAa;AAI1E,aAAQ,GAAwD;AAAA,IAClE;AAAA,EACF;AACF;",
+  "names": []
+}

package/src/elements/hostedSlots.d.ts

@@ -0,0 +1,36 @@
+import type { ShaeEntElement } from './ShaeEntElement.js';
+/**
+ * The `<slot>`s one entity element answers for.
+ *
+ * The owner asks it to take up what it finds — {@link HostedSlots.collect} on the way into the
+ * tree, {@link HostedSlots.takeUp} for a slot that reports — and to let go of everything at
+ * once with {@link HostedSlots.releaseAll}. Everything beyond that it decides for itself.
+ */
+export declare class HostedSlots {
+    #private;
+    constructor(owner: ShaeEntElement);
+    /**
+     * Take up the `<slot>`s below this element that project something.
+     *
+     * A slot is answered for from the moment it reports an assignment, and an entity leaving the
+     * tree lets go of every slot it holds. Entering the tree is the counterpart: the entity takes
+     * up the slots below it, because the assignment inside a shadow root does not change while
+     * its host is out of the document — nothing reports on the way back in, so the entity has to
+     * look for itself.
+     *
+     * Only inside a shadow root, and that test is exact rather than an optimization: a `<slot>`
+     * in a node tree that is not a shadow tree has no assignment and never reports one, so there
+     * is nothing below such an element to take up.
+     */
+    collect(): void;
+    /**
+     * Take up the slot a `slotchange` names, if this element is the closest entity above it.
+     *
+     * `event.target` is the slot that reports, which is what the bubbling channel at the element
+     * carries — a different reading from the one {@link HostedSlots} makes of a `slotchange` on a
+     * slot it listens to itself, where the slot in question is the one the listener hangs on.
+     */
+    takeUp(event: Event): void;
+    releaseAll(): void;
+}
+//# sourceMappingURL=hostedSlots.d.ts.map

package/src/elements/hostedSlots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostedSlots.d.ts","sourceRoot":"","sources":["../../../src/elements/hostedSlots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAiDxD;;;;;;GAMG;AACH,qBAAa,WAAW;;IAUtB,YAAY,KAAK,EAAE,cAAc,EAEhC;IAoDD;;;;;;;;;;;;OAYG;IACH,OAAO,SASN;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK,QAgBlB;IAED,UAAU,SAKT;CACF"}

package/src/elements/hostedSlots.js

@@ -0,0 +1,118 @@
+import { ComponentContext } from "../view/ComponentContext.js";
+const entHostOfSlot = /* @__PURE__ */ new WeakMap();
+const reRequestedForSlotChange = /* @__PURE__ */ new WeakSet();
+const askEveryoneToReRequest = (event) => {
+  if (reRequestedForSlotChange.has(event)) return;
+  reRequestedForSlotChange.add(event);
+  for (const context of ComponentContext.getContextsMap().values()) {
+    context.broadcastEvent(ComponentContext.ReRequestParent);
+    context.broadcastEvent(ComponentContext.ReRequestEntHost);
+  }
+};
+class HostedSlots {
+  #owner;
+  // The `<slot>`s this element currently answers for. A listener on the slot itself is the only
+  // thing that tells the side losing a slot about the loss: `slotchange` fires at the slot,
+  // wherever it has landed, and the ascent from there is the one reading of "is this still mine"
+  // that survives the move. `WeakRef` for the same reason as in the register — a slot that is gone
+  // is held by nobody here.
+  #slots = /* @__PURE__ */ new Set();
+  constructor(owner) {
+    this.#owner = owner;
+  }
+  // Whether this element is the closest entity above `slot`. The ascent goes over `parentElement`
+  // and nothing else, and both callers stand on the same ground for it: `slotchange` bubbles along
+  // the node tree of one shadow root, so the slot and every entity that can hear it sit in the same
+  // tree, and a slot found by `querySelectorAll` never leaves the node tree it was searched in
+  // either. The flattened parent is not the question here. Without the test every entity of the
+  // chain would write the register and the outermost one would win — the answer a projected node
+  // gets comes from the closest.
+  #isClosestEntAbove(slot) {
+    for (let current = slot.parentElement; current != null; current = current.parentElement) {
+      if (current === this.#owner) return true;
+      if (current.isShaeEntElement) return false;
+    }
+    return false;
+  }
+  #watch(slot) {
+    for (const ref of this.#slots) {
+      const el = ref.deref();
+      if (el === void 0) this.#slots.delete(ref);
+      else if (el === slot) return;
+    }
+    this.#slots.add(new WeakRef(slot));
+    slot.addEventListener("slotchange", this.#onSlotChange, { capture: false, passive: false });
+  }
+  #release(slot) {
+    slot.removeEventListener("slotchange", this.#onSlotChange, { capture: false });
+    for (const ref of this.#slots) {
+      const el = ref.deref();
+      if (el === void 0 || el === slot) this.#slots.delete(ref);
+    }
+  }
+  // `currentTarget` rather than `target`: a `<slot>` can stand in the fallback content of another
+  // slot, and what reports then is the inner one while the slot this listener hangs on is the one
+  // in question. The early return on "still mine" hands the whole job — register and round alike —
+  // to the bubbling listener, which would otherwise do it a second time. And the `null` entry: a
+  // slot that comes back to this entity has changed hands twice, and the round has to run for the
+  // second change as well.
+  #onSlotChange = (event) => {
+    const slot = event.currentTarget;
+    if (this.#isClosestEntAbove(slot)) return;
+    this.#release(slot);
+    if (entHostOfSlot.get(slot)?.deref() === this.#owner) {
+      entHostOfSlot.set(slot, null);
+    }
+    askEveryoneToReRequest(event);
+  };
+  /**
+   * Take up the `<slot>`s below this element that project something.
+   *
+   * A slot is answered for from the moment it reports an assignment, and an entity leaving the
+   * tree lets go of every slot it holds. Entering the tree is the counterpart: the entity takes
+   * up the slots below it, because the assignment inside a shadow root does not change while
+   * its host is out of the document — nothing reports on the way back in, so the entity has to
+   * look for itself.
+   *
+   * Only inside a shadow root, and that test is exact rather than an optimization: a `<slot>`
+   * in a node tree that is not a shadow tree has no assignment and never reports one, so there
+   * is nothing below such an element to take up.
+   */
+  collect() {
+    if (this.#owner.findShadowRootHost() == null) return;
+    for (const slot of this.#owner.querySelectorAll("slot")) {
+      if (slot.assignedNodes().length === 0) continue;
+      if (!this.#isClosestEntAbove(slot)) continue;
+      entHostOfSlot.set(slot, new WeakRef(this.#owner));
+      this.#watch(slot);
+    }
+  }
+  /**
+   * Take up the slot a `slotchange` names, if this element is the closest entity above it.
+   *
+   * `event.target` is the slot that reports, which is what the bubbling channel at the element
+   * carries — a different reading from the one {@link HostedSlots} makes of a `slotchange` on a
+   * slot it listens to itself, where the slot in question is the one the listener hangs on.
+   */
+  takeUp(event) {
+    const slot = event.target;
+    if (this.#isClosestEntAbove(slot)) {
+      const previous = entHostOfSlot.get(slot);
+      entHostOfSlot.set(slot, new WeakRef(this.#owner));
+      this.#watch(slot);
+      if (previous !== void 0 && previous?.deref() !== this.#owner) {
+        askEveryoneToReRequest(event);
+      }
+    }
+  }
+  releaseAll() {
+    for (const ref of this.#slots) {
+      ref.deref()?.removeEventListener("slotchange", this.#onSlotChange, { capture: false });
+    }
+    this.#slots.clear();
+  }
+}
+export {
+  HostedSlots
+};
+//# sourceMappingURL=hostedSlots.js.map

package/src/elements/hostedSlots.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/elements/hostedSlots.ts"],
+  "sourcesContent": ["import {ComponentContext} from '../view/ComponentContext.js';\nimport type {ShaeEntElement} from './ShaeEntElement.js';\n\n/**\n * The entity that answers for a `<slot>`, written on either of the two occasions an entity comes\n * to answer for one: the slot reports an assignment and the closest entity above it takes it up,\n * or an entity enters the tree and takes up the slots below it. The reporting writer takes the\n * slot as it finds it: `slotchange` announces every change of an assignment, one that has just\n * become empty included, so an entry can name a slot that projects nothing at this moment. What\n * no entry ever names is a slot that has not reported at all \u2014 and the entering writer holds that\n * line by skipping a slot with an empty assignment, because a name put on such a slot would let\n * its first report, under whatever entity it sits below by then, read as a change of hands.\n *\n * `slotchange` fires after the move and therefore at the new location; the place the slot came\n * from cannot be read from there any more \u2014 this register is the only place where it still has a\n * name. A `WeakMap` so a slot that is gone holds nothing, and a `WeakRef` as its value so a slot\n * that stays does not hold the entity it left: a slot can outlive its entity, and an entry read\n * back as empty is one more way of saying \"not the entity asking now\", which is the only thing\n * the register is ever asked.\n *\n * An entry of `null` names no entity and is still an entry: it says that the entity which answered\n * for this slot has let go of it. That is a different statement from `undefined`, which is a slot\n * nobody has ever reported.\n */\nconst entHostOfSlot = new WeakMap<Element, WeakRef<ShaeEntElement> | null>();\n\n/** The `slotchange` events whose re-request round has already run. */\nconst reRequestedForSlotChange = new WeakSet<Event>();\n\n/**\n * Everything the slot projects hangs on the entity above the slot, and the slot just took a\n * different one. There is no named counterpart to inform: the projected nodes can sit in any\n * namespace, below any entity, and the entities involved are not reachable from here. So the\n * request goes to every candidate there is, in every namespace: a property binds to the closest\n * entity above it whatever namespace that entity carries, and an entity from another namespace can\n * be projected through the same slot.\n *\n * Both sides of a move see the same event \u2014 the entity losing the slot as a listener on the slot\n * itself, the one gaining it while the event bubbles \u2014 and the round either of them would start is\n * the same round over the whole document. Whoever gets here first runs it.\n */\nconst askEveryoneToReRequest = (event: Event): void => {\n  if (reRequestedForSlotChange.has(event)) return;\n  reRequestedForSlotChange.add(event);\n  for (const context of ComponentContext.getContextsMap().values()) {\n    context.broadcastEvent(ComponentContext.ReRequestParent);\n    context.broadcastEvent(ComponentContext.ReRequestEntHost);\n  }\n};\n\n/**\n * The `<slot>`s one entity element answers for.\n *\n * The owner asks it to take up what it finds \u2014 {@link HostedSlots.collect} on the way into the\n * tree, {@link HostedSlots.takeUp} for a slot that reports \u2014 and to let go of everything at\n * once with {@link HostedSlots.releaseAll}. Everything beyond that it decides for itself.\n */\nexport class HostedSlots {\n  readonly #owner: ShaeEntElement;\n\n  // The `<slot>`s this element currently answers for. A listener on the slot itself is the only\n  // thing that tells the side losing a slot about the loss: `slotchange` fires at the slot,\n  // wherever it has landed, and the ascent from there is the one reading of \"is this still mine\"\n  // that survives the move. `WeakRef` for the same reason as in the register \u2014 a slot that is gone\n  // is held by nobody here.\n  readonly #slots = new Set<WeakRef<Element>>();\n\n  constructor(owner: ShaeEntElement) {\n    this.#owner = owner;\n  }\n\n  // Whether this element is the closest entity above `slot`. The ascent goes over `parentElement`\n  // and nothing else, and both callers stand on the same ground for it: `slotchange` bubbles along\n  // the node tree of one shadow root, so the slot and every entity that can hear it sit in the same\n  // tree, and a slot found by `querySelectorAll` never leaves the node tree it was searched in\n  // either. The flattened parent is not the question here. Without the test every entity of the\n  // chain would write the register and the outermost one would win \u2014 the answer a projected node\n  // gets comes from the closest.\n  #isClosestEntAbove(slot: Element): boolean {\n    for (let current = slot.parentElement; current != null; current = current.parentElement) {\n      if (current === this.#owner) return true;\n      if ((current as ShaeEntElement).isShaeEntElement) return false;\n    }\n    return false;\n  }\n\n  #watch(slot: Element) {\n    for (const ref of this.#slots) {\n      const el = ref.deref();\n      if (el === undefined) this.#slots.delete(ref);\n      else if (el === slot) return;\n    }\n    this.#slots.add(new WeakRef(slot));\n    slot.addEventListener('slotchange', this.#onSlotChange, {capture: false, passive: false});\n  }\n\n  #release(slot: Element) {\n    slot.removeEventListener('slotchange', this.#onSlotChange, {capture: false});\n    for (const ref of this.#slots) {\n      const el = ref.deref();\n      if (el === undefined || el === slot) this.#slots.delete(ref);\n    }\n  }\n\n  // `currentTarget` rather than `target`: a `<slot>` can stand in the fallback content of another\n  // slot, and what reports then is the inner one while the slot this listener hangs on is the one\n  // in question. The early return on \"still mine\" hands the whole job \u2014 register and round alike \u2014\n  // to the bubbling listener, which would otherwise do it a second time. And the `null` entry: a\n  // slot that comes back to this entity has changed hands twice, and the round has to run for the\n  // second change as well.\n  #onSlotChange = (event: Event) => {\n    const slot = event.currentTarget as Element;\n    if (this.#isClosestEntAbove(slot)) return;\n\n    this.#release(slot);\n    if (entHostOfSlot.get(slot)?.deref() === this.#owner) {\n      entHostOfSlot.set(slot, null);\n    }\n    askEveryoneToReRequest(event);\n  };\n\n  /**\n   * Take up the `<slot>`s below this element that project something.\n   *\n   * A slot is answered for from the moment it reports an assignment, and an entity leaving the\n   * tree lets go of every slot it holds. Entering the tree is the counterpart: the entity takes\n   * up the slots below it, because the assignment inside a shadow root does not change while\n   * its host is out of the document \u2014 nothing reports on the way back in, so the entity has to\n   * look for itself.\n   *\n   * Only inside a shadow root, and that test is exact rather than an optimization: a `<slot>`\n   * in a node tree that is not a shadow tree has no assignment and never reports one, so there\n   * is nothing below such an element to take up.\n   */\n  collect() {\n    if (this.#owner.findShadowRootHost() == null) return;\n\n    for (const slot of this.#owner.querySelectorAll('slot')) {\n      if (slot.assignedNodes().length === 0) continue;\n      if (!this.#isClosestEntAbove(slot)) continue;\n      entHostOfSlot.set(slot, new WeakRef(this.#owner));\n      this.#watch(slot);\n    }\n  }\n\n  /**\n   * Take up the slot a `slotchange` names, if this element is the closest entity above it.\n   *\n   * `event.target` is the slot that reports, which is what the bubbling channel at the element\n   * carries \u2014 a different reading from the one {@link HostedSlots} makes of a `slotchange` on a\n   * slot it listens to itself, where the slot in question is the one the listener hangs on.\n   */\n  takeUp(event: Event) {\n    const slot = event.target as Element;\n    if (this.#isClosestEntAbove(slot)) {\n      const previous = entHostOfSlot.get(slot);\n      entHostOfSlot.set(slot, new WeakRef(this.#owner));\n      this.#watch(slot);\n      // the gate in front of the round, and it is closed twice. What a slot reporting for the\n      // first time projects is reached by the two calls that frame this block, so the first\n      // registration writes the register and pays nothing beyond it. Afterwards a slot whose\n      // entity above it is the same one as last time reports changed content, and content moves\n      // no binding. What is left is the slot that arrived here from somewhere else \u2014 and an entry\n      // naming nobody is such an arrival too: that slot stood under no entity in between\n      if (previous !== undefined && previous?.deref() !== this.#owner) {\n        askEveryoneToReRequest(event);\n      }\n    }\n  }\n\n  releaseAll() {\n    for (const ref of this.#slots) {\n      ref.deref()?.removeEventListener('slotchange', this.#onSlotChange, {capture: false});\n    }\n    this.#slots.clear();\n  }\n}\n"],
+  "mappings": "AAAA,SAAQ,wBAAuB;AAwB/B,MAAM,gBAAgB,oBAAI,QAAiD;AAG3E,MAAM,2BAA2B,oBAAI,QAAe;AAcpD,MAAM,yBAAyB,CAAC,UAAuB;AACrD,MAAI,yBAAyB,IAAI,KAAK,EAAG;AACzC,2BAAyB,IAAI,KAAK;AAClC,aAAW,WAAW,iBAAiB,eAAe,EAAE,OAAO,GAAG;AAChE,YAAQ,eAAe,iBAAiB,eAAe;AACvD,YAAQ,eAAe,iBAAiB,gBAAgB;AAAA,EAC1D;AACF;AASO,MAAM,YAAY;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAS,oBAAI,IAAsB;AAAA,EAE5C,YAAY,OAAuB;AACjC,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,mBAAmB,MAAwB;AACzC,aAAS,UAAU,KAAK,eAAe,WAAW,MAAM,UAAU,QAAQ,eAAe;AACvF,UAAI,YAAY,KAAK,OAAQ,QAAO;AACpC,UAAK,QAA2B,iBAAkB,QAAO;AAAA,IAC3D;AACA,WAAO;AAAA,EACT;AAAA,EAEA,OAAO,MAAe;AACpB,eAAW,OAAO,KAAK,QAAQ;AAC7B,YAAM,KAAK,IAAI,MAAM;AACrB,UAAI,OAAO,OAAW,MAAK,OAAO,OAAO,GAAG;AAAA,eACnC,OAAO,KAAM;AAAA,IACxB;AACA,SAAK,OAAO,IAAI,IAAI,QAAQ,IAAI,CAAC;AACjC,SAAK,iBAAiB,cAAc,KAAK,eAAe,EAAC,SAAS,OAAO,SAAS,MAAK,CAAC;AAAA,EAC1F;AAAA,EAEA,SAAS,MAAe;AACtB,SAAK,oBAAoB,cAAc,KAAK,eAAe,EAAC,SAAS,MAAK,CAAC;AAC3E,eAAW,OAAO,KAAK,QAAQ;AAC7B,YAAM,KAAK,IAAI,MAAM;AACrB,UAAI,OAAO,UAAa,OAAO,KAAM,MAAK,OAAO,OAAO,GAAG;AAAA,IAC7D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,gBAAgB,CAAC,UAAiB;AAChC,UAAM,OAAO,MAAM;AACnB,QAAI,KAAK,mBAAmB,IAAI,EAAG;AAEnC,SAAK,SAAS,IAAI;AAClB,QAAI,cAAc,IAAI,IAAI,GAAG,MAAM,MAAM,KAAK,QAAQ;AACpD,oBAAc,IAAI,MAAM,IAAI;AAAA,IAC9B;AACA,2BAAuB,KAAK;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,UAAU;AACR,QAAI,KAAK,OAAO,mBAAmB,KAAK,KAAM;AAE9C,eAAW,QAAQ,KAAK,OAAO,iBAAiB,MAAM,GAAG;AACvD,UAAI,KAAK,cAAc,EAAE,WAAW,EAAG;AACvC,UAAI,CAAC,KAAK,mBAAmB,IAAI,EAAG;AACpC,oBAAc,IAAI,MAAM,IAAI,QAAQ,KAAK,MAAM,CAAC;AAChD,WAAK,OAAO,IAAI;AAAA,IAClB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAO,OAAc;AACnB,UAAM,OAAO,MAAM;AACnB,QAAI,KAAK,mBAAmB,IAAI,GAAG;AACjC,YAAM,WAAW,cAAc,IAAI,IAAI;AACvC,oBAAc,IAAI,MAAM,IAAI,QAAQ,KAAK,MAAM,CAAC;AAChD,WAAK,OAAO,IAAI;AAOhB,UAAI,aAAa,UAAa,UAAU,MAAM,MAAM,KAAK,QAAQ;AAC/D,+BAAuB,KAAK;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AAAA,EAEA,aAAa;AACX,eAAW,OAAO,KAAK,QAAQ;AAC7B,UAAI,MAAM,GAAG,oBAAoB,cAAc,KAAK,eAAe,EAAC,SAAS,MAAK,CAAC;AAAA,IACrF;AACA,SAAK,OAAO,MAAM;AAAA,EACpB;AACF;",
+  "names": []
+}

package/src/elements/parentRemoval.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Run `onRemoved` once `node` is taken out of `parent`'s child list.
+ *
+ * A second call for the same pair replaces the callback. The watch ends the moment it fires
+ * — whoever wants to go on watching says so from inside the callback.
+ *
+ * A shared observer can already be sitting on a `childList` record from earlier in the same task
+ * — a sibling taken out a moment ago, still waiting for the microtask that delivers observer
+ * callbacks. Registering `node` now must not let that stale record apply to it once delivery
+ * catches up, so pending records are taken out and dispatched first, against the watchers this
+ * call still finds. `node` itself is not among them yet, so it cannot be the one a stale record
+ * matches — the only nodes a `takeRecords()` batch can name here are ones some earlier call
+ * already put in `parent`'s child list and that have since left it again.
+ */
+export declare const watchForRemovalFrom: (parent: Node, node: Node, onRemoved: () => void) => void;
+/** Stop watching `node` under `parent`. A pair nobody watches is left alone. */
+export declare const stopWatchingForRemovalFrom: (parent: Node, node: Node) => void;
+//# sourceMappingURL=parentRemoval.d.ts.map

package/src/elements/parentRemoval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parentRemoval.d.ts","sourceRoot":"","sources":["../../../src/elements/parentRemoval.ts"],"names":[],"mappings":"AA8EA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,WAAY,IAAI,QAAQ,IAAI,aAAa,MAAM,IAAI,KAAG,IAerF,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,WAAY,IAAI,QAAQ,IAAI,KAAG,IAQrE,CAAC"}

package/src/elements/parentRemoval.js

@@ -0,0 +1,60 @@
+const parentWatches = /* @__PURE__ */ new WeakMap();
+const dispatchRemovals = (watch, mutations) => {
+  const removed = [];
+  for (const { removedNodes } of mutations) {
+    for (const node of removedNodes) {
+      const onRemoved = watch.watchers.get(node);
+      if (onRemoved == null) continue;
+      watch.watchers.delete(node);
+      removed.push(onRemoved);
+    }
+  }
+  for (const onRemoved of removed) {
+    try {
+      onRemoved();
+    } catch (error) {
+      console.error("a removal watcher failed:", error);
+    }
+  }
+};
+const createParentWatch = (parent) => {
+  const watchers = /* @__PURE__ */ new Map();
+  const watch = {
+    observer: new MutationObserver((mutations, activeObserver) => {
+      dispatchRemovals(watch, mutations);
+      if (watchers.size === 0) {
+        activeObserver.disconnect();
+        if (parentWatches.get(parent) === watch) parentWatches.delete(parent);
+      }
+    }),
+    watchers
+  };
+  watch.observer.observe(parent, { childList: true, subtree: false, attributes: false });
+  return watch;
+};
+const watchForRemovalFrom = (parent, node, onRemoved) => {
+  let watch = parentWatches.get(parent);
+  if (watch != null) {
+    dispatchRemovals(watch, watch.observer.takeRecords());
+    watch = parentWatches.get(parent);
+  }
+  if (watch == null) {
+    watch = createParentWatch(parent);
+    parentWatches.set(parent, watch);
+  }
+  watch.watchers.set(node, onRemoved);
+};
+const stopWatchingForRemovalFrom = (parent, node) => {
+  const watch = parentWatches.get(parent);
+  if (watch == null) return;
+  if (!watch.watchers.delete(node)) return;
+  if (watch.watchers.size === 0) {
+    watch.observer.disconnect();
+    parentWatches.delete(parent);
+  }
+};
+export {
+  stopWatchingForRemovalFrom,
+  watchForRemovalFrom
+};
+//# sourceMappingURL=parentRemoval.js.map