@spearwolf/shadow-objects 0.32.0 → 0.34.0

package/src/utils/MicrotaskGate.js

@@ -0,0 +1,20 @@
+class MicrotaskGate {
+  #scheduled = false;
+  #run;
+  constructor(run) {
+    this.#run = run;
+  }
+  /** Ask for the action. */
+  schedule() {
+    if (this.#scheduled) return;
+    this.#scheduled = true;
+    queueMicrotask(() => {
+      this.#scheduled = false;
+      this.#run();
+    });
+  }
+}
+export {
+  MicrotaskGate
+};
+//# sourceMappingURL=MicrotaskGate.js.map

package/src/utils/MicrotaskGate.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/MicrotaskGate.ts"],
+  "sourcesContent": ["/**\n * Runs one action a microtask after it was asked for, however often it is asked for.\n *\n * The flag falls before the action rather than behind it: an action that asks again books a fresh\n * round instead of writing into a flag the line behind it would clear.\n *\n * No batch and no guard: there is one action, so there are no neighbours a failure could cost --\n * what it throws goes where an uncaught microtask goes. A gate that carries entries is\n * `MicrotaskCollector`, a booking that can be called off again is `DeferredTeardown`.\n */\nexport class MicrotaskGate {\n  #scheduled = false;\n\n  readonly #run: () => void;\n\n  constructor(run: () => void) {\n    this.#run = run;\n  }\n\n  /** Ask for the action. */\n  schedule(): void {\n    if (this.#scheduled) return;\n    this.#scheduled = true;\n\n    queueMicrotask(() => {\n      this.#scheduled = false;\n      this.#run();\n    });\n  }\n}\n"],
+  "mappings": "AAUO,MAAM,cAAc;AAAA,EACzB,aAAa;AAAA,EAEJ;AAAA,EAET,YAAY,KAAiB;AAC3B,SAAK,OAAO;AAAA,EACd;AAAA;AAAA,EAGA,WAAiB;AACf,QAAI,KAAK,WAAY;AACrB,SAAK,aAAa;AAElB,mBAAe,MAAM;AACnB,WAAK,aAAa;AAClB,WAAK,KAAK;AAAA,IACZ,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/src/utils/array-utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/array-utils.ts"],
-  "sourcesContent": ["/**\n * Add a new item to the array, but only if it does not already exist\n */\nexport function appendTo<T = unknown>(array: T[], item: T) {\n  const index = array.indexOf(item);\n  if (index === -1) {\n    array.push(item);\n  }\n}\n\n/**\n * Append a new item to the end of the array.\n * If the item exists, remove the previous item first.\n */\nexport function appendToEnd<T = unknown>(array: T[], item: T) {\n  const index = array.indexOf(item);\n  if (index !== -1) {\n    array.splice(index, 1);\n  }\n  array.push(item);\n}\n\nexport function removeFrom<T = unknown>(array: T[], item: T) {\n  const index = array.indexOf(item);\n  if (index !== -1) {\n    array.splice(index, 1);\n  }\n}"],
+  "sourcesContent": ["/**\n * Add a new item to the array, but only if it does not already exist\n */\nexport function appendTo<T = unknown>(array: T[], item: T) {\n  const index = array.indexOf(item);\n  if (index === -1) {\n    array.push(item);\n  }\n}\n\n/**\n * Append a new item to the end of the array.\n * If the item exists, remove the previous item first.\n */\nexport function appendToEnd<T = unknown>(array: T[], item: T) {\n  const index = array.indexOf(item);\n  if (index !== -1) {\n    array.splice(index, 1);\n  }\n  array.push(item);\n}\n\nexport function removeFrom<T = unknown>(array: T[], item: T) {\n  const index = array.indexOf(item);\n  if (index !== -1) {\n    array.splice(index, 1);\n  }\n}\n"],
   "mappings": "AAGO,SAAS,SAAsB,OAAY,MAAS;AACzD,QAAM,QAAQ,MAAM,QAAQ,IAAI;AAChC,MAAI,UAAU,IAAI;AAChB,UAAM,KAAK,IAAI;AAAA,EACjB;AACF;AAMO,SAAS,YAAyB,OAAY,MAAS;AAC5D,QAAM,QAAQ,MAAM,QAAQ,IAAI;AAChC,MAAI,UAAU,IAAI;AAChB,UAAM,OAAO,OAAO,CAAC;AAAA,EACvB;AACA,QAAM,KAAK,IAAI;AACjB;AAEO,SAAS,WAAwB,OAAY,MAAS;AAC3D,QAAM,QAAQ,MAAM,QAAQ,IAAI;AAChC,MAAI,UAAU,IAAI;AAChB,UAAM,OAAO,OAAO,CAAC;AAAA,EACvB;AACF;",
   "names": []
 }

package/src/utils/attr-utils.d.ts

@@ -1,3 +1,9 @@
 export declare const readNamespaceAttribute: (el: HTMLElement) => import("../types.js").NamespaceType;
 export declare const readBooleanAttribute: (el: HTMLElement, name: string) => boolean;
+/**
+ * The attribute read as a number, or `undefined` where the element does not carry it.
+ * `Number()` does the reading, so a value that is not a number reads as `NaN` while an empty
+ * or blank one reads as `0` — whoever asks decides what either of those means.
+ */
+export declare const readNumberAttribute: (el: HTMLElement, name: string) => number | undefined;
 //# sourceMappingURL=attr-utils.d.ts.map

package/src/utils/attr-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attr-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/attr-utils.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,GAAI,IAAI,WAAW,wCAA0C,CAAC;AAEjG,eAAO,MAAM,oBAAoB,GAAI,IAAI,WAAW,EAAE,MAAM,MAAM,YAMjE,CAAC"}
+{"version":3,"file":"attr-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/attr-utils.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,OAAQ,WAAW,wCAAuD,CAAC;AAE9G,eAAO,MAAM,oBAAoB,OAAQ,WAAW,QAAQ,MAAM,YAMjE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,OAAQ,WAAW,QAAQ,MAAM,KAAG,MAAM,GAAG,SACV,CAAC"}

package/src/utils/attr-utils.js

@@ -1,7 +1,7 @@
 import { ATTR_NS } from "../elements/constants.js";
 import { TRUTHY_VALUES } from "./constants.js";
 import { toNamespace } from "./toNamespace.js";
-const readNamespaceAttribute = (el) => toNamespace(el.getAttribute(ATTR_NS));
+const readNamespaceAttribute = (el) => toNamespace(el.getAttribute(ATTR_NS) ?? void 0);
 const readBooleanAttribute = (el, name) => {
   if (el.hasAttribute(name)) {
     const val = el.getAttribute(name)?.trim()?.toLowerCase() || "1";
@@ -9,8 +9,10 @@ const readBooleanAttribute = (el, name) => {
   }
   return false;
 };
+const readNumberAttribute = (el, name) => el.hasAttribute(name) ? Number(el.getAttribute(name)) : void 0;
 export {
   readBooleanAttribute,
-  readNamespaceAttribute
+  readNamespaceAttribute,
+  readNumberAttribute
 };
 //# sourceMappingURL=attr-utils.js.map

package/src/utils/attr-utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/attr-utils.ts"],
-  "sourcesContent": ["import {ATTR_NS} from '../elements/constants.js';\nimport {TRUTHY_VALUES} from './constants.js';\nimport {toNamespace} from './toNamespace.js';\n\nexport const readNamespaceAttribute = (el: HTMLElement) => toNamespace(el.getAttribute(ATTR_NS));\n\nexport const readBooleanAttribute = (el: HTMLElement, name: string) => {\n  if (el.hasAttribute(name)) {\n    const val = el.getAttribute(name)?.trim()?.toLowerCase() || '1';\n    return TRUTHY_VALUES.has(val);\n  }\n  return false;\n};"],
-  "mappings": "AAAA,SAAQ,eAAc;AACtB,SAAQ,qBAAoB;AAC5B,SAAQ,mBAAkB;AAEnB,MAAM,yBAAyB,CAAC,OAAoB,YAAY,GAAG,aAAa,OAAO,CAAC;AAExF,MAAM,uBAAuB,CAAC,IAAiB,SAAiB;AACrE,MAAI,GAAG,aAAa,IAAI,GAAG;AACzB,UAAM,MAAM,GAAG,aAAa,IAAI,GAAG,KAAK,GAAG,YAAY,KAAK;AAC5D,WAAO,cAAc,IAAI,GAAG;AAAA,EAC9B;AACA,SAAO;AACT;",
+  "sourcesContent": ["import {ATTR_NS} from '../elements/constants.js';\nimport {TRUTHY_VALUES} from './constants.js';\nimport {toNamespace} from './toNamespace.js';\n\nexport const readNamespaceAttribute = (el: HTMLElement) => toNamespace(el.getAttribute(ATTR_NS) ?? undefined);\n\nexport const readBooleanAttribute = (el: HTMLElement, name: string) => {\n  if (el.hasAttribute(name)) {\n    const val = el.getAttribute(name)?.trim()?.toLowerCase() || '1';\n    return TRUTHY_VALUES.has(val);\n  }\n  return false;\n};\n\n/**\n * The attribute read as a number, or `undefined` where the element does not carry it.\n * `Number()` does the reading, so a value that is not a number reads as `NaN` while an empty\n * or blank one reads as `0` \u2014 whoever asks decides what either of those means.\n */\nexport const readNumberAttribute = (el: HTMLElement, name: string): number | undefined =>\n  el.hasAttribute(name) ? Number(el.getAttribute(name)) : undefined;\n"],
+  "mappings": "AAAA,SAAQ,eAAc;AACtB,SAAQ,qBAAoB;AAC5B,SAAQ,mBAAkB;AAEnB,MAAM,yBAAyB,CAAC,OAAoB,YAAY,GAAG,aAAa,OAAO,KAAK,MAAS;AAErG,MAAM,uBAAuB,CAAC,IAAiB,SAAiB;AACrE,MAAI,GAAG,aAAa,IAAI,GAAG;AACzB,UAAM,MAAM,GAAG,aAAa,IAAI,GAAG,KAAK,GAAG,YAAY,KAAK;AAC5D,WAAO,cAAc,IAAI,GAAG;AAAA,EAC9B;AACA,SAAO;AACT;AAOO,MAAM,sBAAsB,CAAC,IAAiB,SACnD,GAAG,aAAa,IAAI,IAAI,OAAO,GAAG,aAAa,IAAI,CAAC,IAAI;",
   "names": []
 }

package/src/utils/constants.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/constants.ts"],
-  "sourcesContent": ["export const TRUTHY_VALUES = new Set(['on', 'true', 'yes', 'local', '1']);"],
+  "sourcesContent": ["export const TRUTHY_VALUES = new Set(['on', 'true', 'yes', 'local', '1']);\n"],
   "mappings": "AAAO,MAAM,gBAAgB,oBAAI,IAAI,CAAC,MAAM,QAAQ,OAAO,SAAS,GAAG,CAAC;",
   "names": []
 }

package/src/utils/generateUUID.d.ts

@@ -1,2 +1,13 @@
-export declare const generateUUID: () => string;
+/**
+ * A version-4 uuid in the canonical 8-4-4-4-12 form, from the best source this realm offers.
+ *
+ * Three of them, in order. `crypto.randomUUID()` is bound to a secure context and is out of
+ * reach whenever the page is served over plain http -- a LAN address during development is
+ * the usual way to meet that. `crypto.getRandomValues()` carries no such restriction and is
+ * the same cryptographic generator, so the step down to it costs four lines of formatting and
+ * nothing else. Only a realm with no Web Crypto API at all reaches `Math.random()`, and that
+ * one says so on the console, once: the uuids stay unique enough to name an entity, and they
+ * stop being unguessable.
+ */
+export declare const generateUUID: () => `${string}-${string}-${string}-${string}-${string}`;
 //# sourceMappingURL=generateUUID.d.ts.map

package/src/utils/generateUUID.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateUUID.d.ts","sourceRoot":"","sources":["../../../src/utils/generateUUID.ts"],"names":[],"mappings":"AAsSA,eAAO,MAAM,YAAY,cAA8D,CAAC"}
+{"version":3,"file":"generateUUID.d.ts","sourceRoot":"","sources":["../../../src/utils/generateUUID.ts"],"names":[],"mappings":"AAqDA;;;;;;;;;;GAUG;AAKH,eAAO,MAAM,YAAY,2DAYxB,CAAC"}

package/src/utils/generateUUID.js

@@ -1,270 +1,35 @@
-const _lut = [
-  "00",
-  "01",
-  "02",
-  "03",
-  "04",
-  "05",
-  "06",
-  "07",
-  "08",
-  "09",
-  "0a",
-  "0b",
-  "0c",
-  "0d",
-  "0e",
-  "0f",
-  "10",
-  "11",
-  "12",
-  "13",
-  "14",
-  "15",
-  "16",
-  "17",
-  "18",
-  "19",
-  "1a",
-  "1b",
-  "1c",
-  "1d",
-  "1e",
-  "1f",
-  "20",
-  "21",
-  "22",
-  "23",
-  "24",
-  "25",
-  "26",
-  "27",
-  "28",
-  "29",
-  "2a",
-  "2b",
-  "2c",
-  "2d",
-  "2e",
-  "2f",
-  "30",
-  "31",
-  "32",
-  "33",
-  "34",
-  "35",
-  "36",
-  "37",
-  "38",
-  "39",
-  "3a",
-  "3b",
-  "3c",
-  "3d",
-  "3e",
-  "3f",
-  "40",
-  "41",
-  "42",
-  "43",
-  "44",
-  "45",
-  "46",
-  "47",
-  "48",
-  "49",
-  "4a",
-  "4b",
-  "4c",
-  "4d",
-  "4e",
-  "4f",
-  "50",
-  "51",
-  "52",
-  "53",
-  "54",
-  "55",
-  "56",
-  "57",
-  "58",
-  "59",
-  "5a",
-  "5b",
-  "5c",
-  "5d",
-  "5e",
-  "5f",
-  "60",
-  "61",
-  "62",
-  "63",
-  "64",
-  "65",
-  "66",
-  "67",
-  "68",
-  "69",
-  "6a",
-  "6b",
-  "6c",
-  "6d",
-  "6e",
-  "6f",
-  "70",
-  "71",
-  "72",
-  "73",
-  "74",
-  "75",
-  "76",
-  "77",
-  "78",
-  "79",
-  "7a",
-  "7b",
-  "7c",
-  "7d",
-  "7e",
-  "7f",
-  "80",
-  "81",
-  "82",
-  "83",
-  "84",
-  "85",
-  "86",
-  "87",
-  "88",
-  "89",
-  "8a",
-  "8b",
-  "8c",
-  "8d",
-  "8e",
-  "8f",
-  "90",
-  "91",
-  "92",
-  "93",
-  "94",
-  "95",
-  "96",
-  "97",
-  "98",
-  "99",
-  "9a",
-  "9b",
-  "9c",
-  "9d",
-  "9e",
-  "9f",
-  "a0",
-  "a1",
-  "a2",
-  "a3",
-  "a4",
-  "a5",
-  "a6",
-  "a7",
-  "a8",
-  "a9",
-  "aa",
-  "ab",
-  "ac",
-  "ad",
-  "ae",
-  "af",
-  "b0",
-  "b1",
-  "b2",
-  "b3",
-  "b4",
-  "b5",
-  "b6",
-  "b7",
-  "b8",
-  "b9",
-  "ba",
-  "bb",
-  "bc",
-  "bd",
-  "be",
-  "bf",
-  "c0",
-  "c1",
-  "c2",
-  "c3",
-  "c4",
-  "c5",
-  "c6",
-  "c7",
-  "c8",
-  "c9",
-  "ca",
-  "cb",
-  "cc",
-  "cd",
-  "ce",
-  "cf",
-  "d0",
-  "d1",
-  "d2",
-  "d3",
-  "d4",
-  "d5",
-  "d6",
-  "d7",
-  "d8",
-  "d9",
-  "da",
-  "db",
-  "dc",
-  "dd",
-  "de",
-  "df",
-  "e0",
-  "e1",
-  "e2",
-  "e3",
-  "e4",
-  "e5",
-  "e6",
-  "e7",
-  "e8",
-  "e9",
-  "ea",
-  "eb",
-  "ec",
-  "ed",
-  "ee",
-  "ef",
-  "f0",
-  "f1",
-  "f2",
-  "f3",
-  "f4",
-  "f5",
-  "f6",
-  "f7",
-  "f8",
-  "f9",
-  "fa",
-  "fb",
-  "fc",
-  "fd",
-  "fe",
-  "ff"
-];
-const _generateUUID = () => {
-  const d0 = Math.random() * 4294967295 | 0;
-  const d1 = Math.random() * 4294967295 | 0;
-  const d2 = Math.random() * 4294967295 | 0;
-  const d3 = Math.random() * 4294967295 | 0;
-  const uuid = _lut[d0 & 255] + _lut[d0 >> 8 & 255] + _lut[d0 >> 16 & 255] + _lut[d0 >> 24 & 255] + "-" + _lut[d1 & 255] + _lut[d1 >> 8 & 255] + "-" + _lut[d1 >> 16 & 15 | 64] + _lut[d1 >> 24 & 255] + "-" + _lut[d2 & 63 | 128] + _lut[d2 >> 8 & 255] + "-" + _lut[d2 >> 16 & 255] + _lut[d2 >> 24 & 255] + _lut[d3 & 255] + _lut[d3 >> 8 & 255] + _lut[d3 >> 16 & 255] + _lut[d3 >> 24 & 255];
-  return uuid.toLowerCase();
+import { ConsoleLogger } from "./ConsoleLogger.js";
+const UUID_BYTE_COUNT = 16;
+const toUuidV4 = (bytes) => {
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+let mathRandomAnnounced = false;
+const mathRandomBytes = () => {
+  if (!mathRandomAnnounced) {
+    mathRandomAnnounced = true;
+    new ConsoleLogger("generateUUID").error(
+      "no Web Crypto API in this realm: entity uuids come from Math.random() and are not unguessable"
+    );
+  }
+  const bytes = new Uint8Array(UUID_BYTE_COUNT);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Math.random() * 256 | 0;
+  }
+  return bytes;
+};
+const generateUUID = () => {
+  const webCrypto = globalThis.crypto;
+  if (typeof webCrypto?.randomUUID === "function") {
+    return webCrypto.randomUUID();
+  }
+  if (typeof webCrypto?.getRandomValues === "function") {
+    return toUuidV4(webCrypto.getRandomValues(new Uint8Array(UUID_BYTE_COUNT)));
+  }
+  return toUuidV4(mathRandomBytes());
 };
-const generateUUID = () => globalThis?.crypto?.randomUUID?.() ?? _generateUUID();
 export {
   generateUUID
 };

package/src/utils/generateUUID.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/generateUUID.ts"],
-  "sourcesContent": ["// https://github.com/mrdoob/three.js/blob/master/src/math/MathUtils.js\n\n// prettier-ignore\nconst _lut = [\n  '00',\n  '01',\n  '02',\n  '03',\n  '04',\n  '05',\n  '06',\n  '07',\n  '08',\n  '09',\n  '0a',\n  '0b',\n  '0c',\n  '0d',\n  '0e',\n  '0f',\n  '10',\n  '11',\n  '12',\n  '13',\n  '14',\n  '15',\n  '16',\n  '17',\n  '18',\n  '19',\n  '1a',\n  '1b',\n  '1c',\n  '1d',\n  '1e',\n  '1f',\n  '20',\n  '21',\n  '22',\n  '23',\n  '24',\n  '25',\n  '26',\n  '27',\n  '28',\n  '29',\n  '2a',\n  '2b',\n  '2c',\n  '2d',\n  '2e',\n  '2f',\n  '30',\n  '31',\n  '32',\n  '33',\n  '34',\n  '35',\n  '36',\n  '37',\n  '38',\n  '39',\n  '3a',\n  '3b',\n  '3c',\n  '3d',\n  '3e',\n  '3f',\n  '40',\n  '41',\n  '42',\n  '43',\n  '44',\n  '45',\n  '46',\n  '47',\n  '48',\n  '49',\n  '4a',\n  '4b',\n  '4c',\n  '4d',\n  '4e',\n  '4f',\n  '50',\n  '51',\n  '52',\n  '53',\n  '54',\n  '55',\n  '56',\n  '57',\n  '58',\n  '59',\n  '5a',\n  '5b',\n  '5c',\n  '5d',\n  '5e',\n  '5f',\n  '60',\n  '61',\n  '62',\n  '63',\n  '64',\n  '65',\n  '66',\n  '67',\n  '68',\n  '69',\n  '6a',\n  '6b',\n  '6c',\n  '6d',\n  '6e',\n  '6f',\n  '70',\n  '71',\n  '72',\n  '73',\n  '74',\n  '75',\n  '76',\n  '77',\n  '78',\n  '79',\n  '7a',\n  '7b',\n  '7c',\n  '7d',\n  '7e',\n  '7f',\n  '80',\n  '81',\n  '82',\n  '83',\n  '84',\n  '85',\n  '86',\n  '87',\n  '88',\n  '89',\n  '8a',\n  '8b',\n  '8c',\n  '8d',\n  '8e',\n  '8f',\n  '90',\n  '91',\n  '92',\n  '93',\n  '94',\n  '95',\n  '96',\n  '97',\n  '98',\n  '99',\n  '9a',\n  '9b',\n  '9c',\n  '9d',\n  '9e',\n  '9f',\n  'a0',\n  'a1',\n  'a2',\n  'a3',\n  'a4',\n  'a5',\n  'a6',\n  'a7',\n  'a8',\n  'a9',\n  'aa',\n  'ab',\n  'ac',\n  'ad',\n  'ae',\n  'af',\n  'b0',\n  'b1',\n  'b2',\n  'b3',\n  'b4',\n  'b5',\n  'b6',\n  'b7',\n  'b8',\n  'b9',\n  'ba',\n  'bb',\n  'bc',\n  'bd',\n  'be',\n  'bf',\n  'c0',\n  'c1',\n  'c2',\n  'c3',\n  'c4',\n  'c5',\n  'c6',\n  'c7',\n  'c8',\n  'c9',\n  'ca',\n  'cb',\n  'cc',\n  'cd',\n  'ce',\n  'cf',\n  'd0',\n  'd1',\n  'd2',\n  'd3',\n  'd4',\n  'd5',\n  'd6',\n  'd7',\n  'd8',\n  'd9',\n  'da',\n  'db',\n  'dc',\n  'dd',\n  'de',\n  'df',\n  'e0',\n  'e1',\n  'e2',\n  'e3',\n  'e4',\n  'e5',\n  'e6',\n  'e7',\n  'e8',\n  'e9',\n  'ea',\n  'eb',\n  'ec',\n  'ed',\n  'ee',\n  'ef',\n  'f0',\n  'f1',\n  'f2',\n  'f3',\n  'f4',\n  'f5',\n  'f6',\n  'f7',\n  'f8',\n  'f9',\n  'fa',\n  'fb',\n  'fc',\n  'fd',\n  'fe',\n  'ff',\n];\n\nconst _generateUUID = () => {\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136\n  const d0 = (Math.random() * 0xffffffff) | 0;\n  const d1 = (Math.random() * 0xffffffff) | 0;\n  const d2 = (Math.random() * 0xffffffff) | 0;\n  const d3 = (Math.random() * 0xffffffff) | 0;\n  const uuid =\n    _lut[d0 & 0xff] +\n    _lut[(d0 >> 8) & 0xff] +\n    _lut[(d0 >> 16) & 0xff] +\n    _lut[(d0 >> 24) & 0xff] +\n    '-' +\n    _lut[d1 & 0xff] +\n    _lut[(d1 >> 8) & 0xff] +\n    '-' +\n    _lut[((d1 >> 16) & 0x0f) | 0x40] +\n    _lut[(d1 >> 24) & 0xff] +\n    '-' +\n    _lut[(d2 & 0x3f) | 0x80] +\n    _lut[(d2 >> 8) & 0xff] +\n    '-' +\n    _lut[(d2 >> 16) & 0xff] +\n    _lut[(d2 >> 24) & 0xff] +\n    _lut[d3 & 0xff] +\n    _lut[(d3 >> 8) & 0xff] +\n    _lut[(d3 >> 16) & 0xff] +\n    _lut[(d3 >> 24) & 0xff];\n\n  // .toLowerCase() here flattens concatenated strings to save heap memory space.\n  return uuid.toLowerCase();\n};\n\nexport const generateUUID = () => globalThis?.crypto?.randomUUID?.() ?? _generateUUID();"],
-  "mappings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gBAAgB,MAAM;AAE1B,QAAM,KAAM,KAAK,OAAO,IAAI,aAAc;AAC1C,QAAM,KAAM,KAAK,OAAO,IAAI,aAAc;AAC1C,QAAM,KAAM,KAAK,OAAO,IAAI,aAAc;AAC1C,QAAM,KAAM,KAAK,OAAO,IAAI,aAAc;AAC1C,QAAM,OACJ,KAAK,KAAK,GAAI,IACd,KAAM,MAAM,IAAK,GAAI,IACrB,KAAM,MAAM,KAAM,GAAI,IACtB,KAAM,MAAM,KAAM,GAAI,IACtB,MACA,KAAK,KAAK,GAAI,IACd,KAAM,MAAM,IAAK,GAAI,IACrB,MACA,KAAO,MAAM,KAAM,KAAQ,EAAI,IAC/B,KAAM,MAAM,KAAM,GAAI,IACtB,MACA,KAAM,KAAK,KAAQ,GAAI,IACvB,KAAM,MAAM,IAAK,GAAI,IACrB,MACA,KAAM,MAAM,KAAM,GAAI,IACtB,KAAM,MAAM,KAAM,GAAI,IACtB,KAAK,KAAK,GAAI,IACd,KAAM,MAAM,IAAK,GAAI,IACrB,KAAM,MAAM,KAAM,GAAI,IACtB,KAAM,MAAM,KAAM,GAAI;AAGxB,SAAO,KAAK,YAAY;AAC1B;AAEO,MAAM,eAAe,MAAM,YAAY,QAAQ,aAAa,KAAK,cAAc;",
+  "sourcesContent": ["import {ConsoleLogger} from './ConsoleLogger.js';\n\n// A uuid here names one Entity and nothing else: it is not a credential, it is not a\n// capability, and it never leaves the process that made it. That is what makes the last of\n// the three sources below tolerable at all, and why it is loud rather than forbidden.\n\nconst UUID_BYTE_COUNT = 16;\n\n// Named after `crypto.randomUUID()`'s own return type instead of spelling out the template\n// literal a second time: the two stay in lockstep by construction, not by copy-paste.\ntype UuidV4 = ReturnType<Crypto['randomUUID']>;\n\n/**\n * Stamps the version and variant bits into 16 random bytes and writes them out in the\n * canonical 8-4-4-4-12 form. The bytes are written to in place, so the caller hands over an\n * array it does not keep.\n *\n * RFC 4122 \u00A74.4: version 4 goes into the high nibble of byte 6, the variant `10xx` into the\n * two high bits of byte 8.\n */\nconst toUuidV4 = (bytes: Uint8Array): UuidV4 => {\n  bytes[6] = (bytes[6]! & 0x0f) | 0x40;\n  bytes[8] = (bytes[8]! & 0x3f) | 0x80;\n\n  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');\n\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}` as UuidV4;\n};\n\nlet mathRandomAnnounced = false;\n\nconst mathRandomBytes = (): Uint8Array => {\n  if (!mathRandomAnnounced) {\n    mathRandomAnnounced = true;\n    // Once per realm, not once per uuid: an application that makes thousands of them would\n    // bury its console, and what is reported is a property of the realm, not of the call.\n    //\n    // Through `error` and not `warn`: `logger.error` always prints, where `logger.warn` is\n    // gated behind `isWarn`, which is off outside `localhost`. Which source a realm offers is\n    // a property of the host the application is served from, so this line has to arrive there\n    // -- a loopback host is the one place where it does not matter.\n    new ConsoleLogger('generateUUID').error(\n      'no Web Crypto API in this realm: entity uuids come from Math.random() and are not unguessable',\n    );\n  }\n\n  const bytes = new Uint8Array(UUID_BYTE_COUNT);\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = (Math.random() * 256) | 0;\n  }\n  return bytes;\n};\n\n/**\n * A version-4 uuid in the canonical 8-4-4-4-12 form, from the best source this realm offers.\n *\n * Three of them, in order. `crypto.randomUUID()` is bound to a secure context and is out of\n * reach whenever the page is served over plain http -- a LAN address during development is\n * the usual way to meet that. `crypto.getRandomValues()` carries no such restriction and is\n * the same cryptographic generator, so the step down to it costs four lines of formatting and\n * nothing else. Only a realm with no Web Crypto API at all reaches `Math.random()`, and that\n * one says so on the console, once: the uuids stay unique enough to name an entity, and they\n * stop being unguessable.\n */\n// No explicit return-type annotation here: emitDeclarationOnly then prints the inferred\n// template-literal form of `UuidV4` rather than the alias name, so callers reading the\n// emitted `.d.ts` see the exact shape `crypto.randomUUID()` guarantees, not a reference they\n// would have to look up.\nexport const generateUUID = () => {\n  const webCrypto = (globalThis as {crypto?: Crypto}).crypto;\n\n  if (typeof webCrypto?.randomUUID === 'function') {\n    return webCrypto.randomUUID();\n  }\n\n  if (typeof webCrypto?.getRandomValues === 'function') {\n    return toUuidV4(webCrypto.getRandomValues(new Uint8Array(UUID_BYTE_COUNT)));\n  }\n\n  return toUuidV4(mathRandomBytes());\n};\n"],
+  "mappings": "AAAA,SAAQ,qBAAoB;AAM5B,MAAM,kBAAkB;AAcxB,MAAM,WAAW,CAAC,UAA8B;AAC9C,QAAM,CAAC,IAAK,MAAM,CAAC,IAAK,KAAQ;AAChC,QAAM,CAAC,IAAK,MAAM,CAAC,IAAK,KAAQ;AAEhC,QAAM,MAAM,MAAM,KAAK,OAAO,CAAC,SAAS,KAAK,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAEnF,SAAO,GAAG,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI,MAAM,GAAG,EAAE,CAAC,IAAI,IAAI,MAAM,IAAI,EAAE,CAAC,IAAI,IAAI,MAAM,IAAI,EAAE,CAAC,IAAI,IAAI,MAAM,EAAE,CAAC;AAC1G;AAEA,IAAI,sBAAsB;AAE1B,MAAM,kBAAkB,MAAkB;AACxC,MAAI,CAAC,qBAAqB;AACxB,0BAAsB;AAQtB,QAAI,cAAc,cAAc,EAAE;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAEA,QAAM,QAAQ,IAAI,WAAW,eAAe;AAC5C,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAM,CAAC,IAAK,KAAK,OAAO,IAAI,MAAO;AAAA,EACrC;AACA,SAAO;AACT;AAiBO,MAAM,eAAe,MAAM;AAChC,QAAM,YAAa,WAAiC;AAEpD,MAAI,OAAO,WAAW,eAAe,YAAY;AAC/C,WAAO,UAAU,WAAW;AAAA,EAC9B;AAEA,MAAI,OAAO,WAAW,oBAAoB,YAAY;AACpD,WAAO,SAAS,UAAU,gBAAgB,IAAI,WAAW,eAAe,CAAC,CAAC;AAAA,EAC5E;AAEA,SAAO,SAAS,gBAAgB,CAAC;AACnC;",
   "names": []
 }

package/src/utils/props-utils.d.ts

@@ -1,8 +1,9 @@
 import type { ComponentPropertiesType } from '../types.js';
-export declare const filterUndefinedProps: (props: ComponentPropertiesType | undefined) => [string, unknown][];
+export declare const filterUndefinedProps: (props: ComponentPropertiesType | undefined) => ([string] | [string, unknown])[] | undefined;
 /**
  * Maybe `curProps` will be modified and returned. But it can also return a newly created array. `changes` will never be modified.
+ * The result never shares a tuple with `changes` — except when `curProps === changes`, where `changes`, tuples included, comes back as-is.
+ * A list the changes empty out comes back as `undefined`, never as an empty array.
  */
 export declare const applyPropsChanges: (curProps: ComponentPropertiesType | undefined, changes: ComponentPropertiesType | undefined) => ComponentPropertiesType | undefined;
-export declare const propsEqual: (a: ComponentPropertiesType | undefined, b: ComponentPropertiesType | undefined) => boolean;
 //# sourceMappingURL=props-utils.d.ts.map

package/src/utils/props-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"props-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/props-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,oBAAoB,GAAI,OAAO,uBAAuB,GAAG,SAAS,wBAG9E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,uBAAuB,GAAG,SAAS,EAC7C,SAAS,uBAAuB,GAAG,SAAS,KAC3C,uBAAuB,GAAG,SAc5B,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,GAAG,uBAAuB,GAAG,SAAS,EAAE,GAAG,uBAAuB,GAAG,SAAS,YAaxG,CAAC"}
+{"version":3,"file":"props-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/props-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,oBAAoB,UAAW,uBAAuB,GAAG,SAAS,iDAO9E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aAClB,uBAAuB,GAAG,SAAS,WACpC,uBAAuB,GAAG,SAAS,KAC3C,uBAAuB,GAAG,SAqB5B,CAAC"}

package/src/utils/props-utils.js

@@ -1,38 +1,27 @@
 const filterUndefinedProps = (props) => {
-  if (props === void 0 || props.length === 0) return void 0;
-  return props.filter((entry) => entry.length === 1 || entry[1] !== void 0);
+  if (props === void 0) return void 0;
+  const kept = props.filter((entry) => entry.length === 1 || entry[1] !== void 0);
+  return kept.length === 0 ? void 0 : kept;
 };
 const applyPropsChanges = (curProps, changes) => {
   if (curProps === changes) return curProps;
   if (changes === void 0) return curProps;
-  if (curProps === void 0) return filterUndefinedProps(changes);
-  for (const [key, value] of changes) {
-    const entry = curProps.find(([k]) => k === key);
-    if (entry === void 0) {
-      curProps.push([key, value]);
+  if (curProps === void 0)
+    return filterUndefinedProps(changes)?.map((entry) => entry.length === 1 ? [entry[0]] : [entry[0], entry[1]]);
+  for (const change of changes) {
+    const key = change[0];
+    const next = change.length === 1 ? [key] : [key, change[1]];
+    const idx = curProps.findIndex(([k]) => k === key);
+    if (idx === -1) {
+      curProps.push(next);
     } else {
-      entry[1] = value;
+      curProps[idx] = next;
     }
   }
   return filterUndefinedProps(curProps);
 };
-const propsEqual = (a, b) => {
-  if (a === b) return true;
-  a = filterUndefinedProps(a);
-  b = filterUndefinedProps(b);
-  if (a === b) return true;
-  if (a === void 0 || b === void 0) return false;
-  if (a.length !== b.length) return false;
-  for (const [aKey, value] of a) {
-    const bEntry = b.find(([bKey]) => aKey === bKey);
-    if (bEntry === void 0) return false;
-    if (bEntry[1] !== value) return false;
-  }
-  return true;
-};
 export {
   applyPropsChanges,
-  filterUndefinedProps,
-  propsEqual
+  filterUndefinedProps
 };
 //# sourceMappingURL=props-utils.js.map

package/src/utils/props-utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/utils/props-utils.ts"],
-  "sourcesContent": ["import type {ComponentPropertiesType} from '../types.js';\n\nexport const filterUndefinedProps = (props: ComponentPropertiesType | undefined) => {\n  if (props === undefined || props.length === 0) return undefined;\n  return props.filter((entry) => (entry as Array<any>).length === 1 || entry[1] !== undefined);\n};\n\n/**\n * Maybe `curProps` will be modified and returned. But it can also return a newly created array. `changes` will never be modified.\n */\nexport const applyPropsChanges = (\n  curProps: ComponentPropertiesType | undefined,\n  changes: ComponentPropertiesType | undefined,\n): ComponentPropertiesType | undefined => {\n  if (curProps === changes) return curProps;\n  if (changes === undefined) return curProps;\n  if (curProps === undefined) return filterUndefinedProps(changes);\n\n  for (const [key, value] of changes) {\n    const entry = curProps.find(([k]) => k === key);\n    if (entry === undefined) {\n      curProps.push([key, value]);\n    } else {\n      entry[1] = value;\n    }\n  }\n  return filterUndefinedProps(curProps);\n};\n\nexport const propsEqual = (a: ComponentPropertiesType | undefined, b: ComponentPropertiesType | undefined) => {\n  if (a === b) return true;\n  a = filterUndefinedProps(a);\n  b = filterUndefinedProps(b);\n  if (a === b) return true;\n  if (a === undefined || b === undefined) return false;\n  if (a.length !== b.length) return false;\n  for (const [aKey, value] of a) {\n    const bEntry = b.find(([bKey]) => aKey === bKey);\n    if (bEntry === undefined) return false;\n    if (bEntry[1] !== value) return false;\n  }\n  return true;\n};"],
-  "mappings": "AAEO,MAAM,uBAAuB,CAAC,UAA+C;AAClF,MAAI,UAAU,UAAa,MAAM,WAAW,EAAG,QAAO;AACtD,SAAO,MAAM,OAAO,CAAC,UAAW,MAAqB,WAAW,KAAK,MAAM,CAAC,MAAM,MAAS;AAC7F;AAKO,MAAM,oBAAoB,CAC/B,UACA,YACwC;AACxC,MAAI,aAAa,QAAS,QAAO;AACjC,MAAI,YAAY,OAAW,QAAO;AAClC,MAAI,aAAa,OAAW,QAAO,qBAAqB,OAAO;AAE/D,aAAW,CAAC,KAAK,KAAK,KAAK,SAAS;AAClC,UAAM,QAAQ,SAAS,KAAK,CAAC,CAAC,CAAC,MAAM,MAAM,GAAG;AAC9C,QAAI,UAAU,QAAW;AACvB,eAAS,KAAK,CAAC,KAAK,KAAK,CAAC;AAAA,IAC5B,OAAO;AACL,YAAM,CAAC,IAAI;AAAA,IACb;AAAA,EACF;AACA,SAAO,qBAAqB,QAAQ;AACtC;AAEO,MAAM,aAAa,CAAC,GAAwC,MAA2C;AAC5G,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,qBAAqB,CAAC;AAC1B,MAAI,qBAAqB,CAAC;AAC1B,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,MAAM,UAAa,MAAM,OAAW,QAAO;AAC/C,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,aAAW,CAAC,MAAM,KAAK,KAAK,GAAG;AAC7B,UAAM,SAAS,EAAE,KAAK,CAAC,CAAC,IAAI,MAAM,SAAS,IAAI;AAC/C,QAAI,WAAW,OAAW,QAAO;AACjC,QAAI,OAAO,CAAC,MAAM,MAAO,QAAO;AAAA,EAClC;AACA,SAAO;AACT;",
+  "sourcesContent": ["import type {ComponentPropertiesType} from '../types.js';\n\nexport const filterUndefinedProps = (props: ComponentPropertiesType | undefined) => {\n  if (props === undefined) return undefined;\n  // an entry that names only the key survives the filter: it means \"set, without a value\", while\n  // `[key, undefined]` means the value is gone. See ComponentPropertiesType for the whole rule\n  const kept = props.filter((entry) => entry.length === 1 || entry[1] !== undefined);\n  // \"nothing\" has one form here: whoever gets an array gets one with at least one entry in it\n  return kept.length === 0 ? undefined : kept;\n};\n\n/**\n * Maybe `curProps` will be modified and returned. But it can also return a newly created array. `changes` will never be modified.\n * The result never shares a tuple with `changes` \u2014 except when `curProps === changes`, where `changes`, tuples included, comes back as-is.\n * A list the changes empty out comes back as `undefined`, never as an empty array.\n */\nexport const applyPropsChanges = (\n  curProps: ComponentPropertiesType | undefined,\n  changes: ComponentPropertiesType | undefined,\n): ComponentPropertiesType | undefined => {\n  if (curProps === changes) return curProps;\n  if (changes === undefined) return curProps;\n  // the tuples belong to `changes` \u2014 a change trail that has been handed out is a value, and\n  // every entry that stays here is one this function built itself\n  if (curProps === undefined)\n    return filterUndefinedProps(changes)?.map((entry) => (entry.length === 1 ? [entry[0]] : [entry[0], entry[1]]));\n\n  for (const change of changes) {\n    const key = change[0];\n    // the arity carries the meaning: a one-element entry says \"set, without a value\" and has to\n    // stay one element on the way in, so the length decides the shape of the copy\n    const next: [string] | [string, unknown] = change.length === 1 ? [key] : [key, change[1]];\n    const idx = curProps.findIndex(([k]) => k === key);\n    if (idx === -1) {\n      curProps.push(next);\n    } else {\n      curProps[idx] = next;\n    }\n  }\n  return filterUndefinedProps(curProps);\n};\n"],
+  "mappings": "AAEO,MAAM,uBAAuB,CAAC,UAA+C;AAClF,MAAI,UAAU,OAAW,QAAO;AAGhC,QAAM,OAAO,MAAM,OAAO,CAAC,UAAU,MAAM,WAAW,KAAK,MAAM,CAAC,MAAM,MAAS;AAEjF,SAAO,KAAK,WAAW,IAAI,SAAY;AACzC;AAOO,MAAM,oBAAoB,CAC/B,UACA,YACwC;AACxC,MAAI,aAAa,QAAS,QAAO;AACjC,MAAI,YAAY,OAAW,QAAO;AAGlC,MAAI,aAAa;AACf,WAAO,qBAAqB,OAAO,GAAG,IAAI,CAAC,UAAW,MAAM,WAAW,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAE;AAE/G,aAAW,UAAU,SAAS;AAC5B,UAAM,MAAM,OAAO,CAAC;AAGpB,UAAM,OAAqC,OAAO,WAAW,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC;AACxF,UAAM,MAAM,SAAS,UAAU,CAAC,CAAC,CAAC,MAAM,MAAM,GAAG;AACjD,QAAI,QAAQ,IAAI;AACd,eAAS,KAAK,IAAI;AAAA,IACpB,OAAO;AACL,eAAS,GAAG,IAAI;AAAA,IAClB;AAAA,EACF;AACA,SAAO,qBAAqB,QAAQ;AACtC;",
   "names": []
 }

package/src/utils/runGuarded.d.ts

@@ -0,0 +1,27 @@
+import type { ConsoleLogger } from './ConsoleLogger.js';
+/**
+ * Runs one teardown step and keeps whatever it throws to itself.
+ *
+ * The kernel answers a failure on two paths. A path that builds hands its error to the caller and
+ * takes back what it had already built, so the caller learns that nothing of its request stands. A
+ * path that tears down catches per step, reports it and carries on, because there is no caller left
+ * to decide anything and the steps behind the failing one still have to run. This function carries
+ * that second promise: a step that fails costs itself and nothing around it.
+ *
+ * A report always reads `message`, then whatever names the subject of the step, then the error. The
+ * error goes last, and this is the one place that decides so -- a caller hands over its identity
+ * arguments and never the error itself.
+ *
+ * `logger.error` sits behind no switch, so these reports stay visible outside localhost, where a
+ * failing teardown would otherwise be silent.
+ *
+ * The behaviour a consumer sees from this is written out in the section "Two error contracts" of
+ * `docs/api-reference.md`.
+ *
+ * @param message names the step that failed, in the tone `<subject> … failed:` or
+ *   `<subject> could not …:`, and ends on a colon.
+ * @param details name what the step worked on, the most specific first -- the display name of a
+ *   shadow object before the uuid of its entity.
+ */
+export declare function runGuarded(logger: ConsoleLogger, run: () => void, message: string, ...details: unknown[]): void;
+//# sourceMappingURL=runGuarded.d.ts.map

package/src/utils/runGuarded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runGuarded.d.ts","sourceRoot":"","sources":["../../../src/utils/runGuarded.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,CAM/G"}

package/src/utils/runGuarded.js

@@ -0,0 +1,11 @@
+function runGuarded(logger, run, message, ...details) {
+  try {
+    run();
+  } catch (error) {
+    logger.error(message, ...details, error);
+  }
+}
+export {
+  runGuarded
+};
+//# sourceMappingURL=runGuarded.js.map

package/src/utils/runGuarded.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/runGuarded.ts"],
+  "sourcesContent": ["import type {ConsoleLogger} from './ConsoleLogger.js';\n\n/**\n * Runs one teardown step and keeps whatever it throws to itself.\n *\n * The kernel answers a failure on two paths. A path that builds hands its error to the caller and\n * takes back what it had already built, so the caller learns that nothing of its request stands. A\n * path that tears down catches per step, reports it and carries on, because there is no caller left\n * to decide anything and the steps behind the failing one still have to run. This function carries\n * that second promise: a step that fails costs itself and nothing around it.\n *\n * A report always reads `message`, then whatever names the subject of the step, then the error. The\n * error goes last, and this is the one place that decides so -- a caller hands over its identity\n * arguments and never the error itself.\n *\n * `logger.error` sits behind no switch, so these reports stay visible outside localhost, where a\n * failing teardown would otherwise be silent.\n *\n * The behaviour a consumer sees from this is written out in the section \"Two error contracts\" of\n * `docs/api-reference.md`.\n *\n * @param message names the step that failed, in the tone `<subject> \u2026 failed:` or\n *   `<subject> could not \u2026:`, and ends on a colon.\n * @param details name what the step worked on, the most specific first -- the display name of a\n *   shadow object before the uuid of its entity.\n */\nexport function runGuarded(logger: ConsoleLogger, run: () => void, message: string, ...details: unknown[]): void {\n  try {\n    run();\n  } catch (error) {\n    logger.error(message, ...details, error);\n  }\n}\n"],
+  "mappings": "AA0BO,SAAS,WAAW,QAAuB,KAAiB,YAAoB,SAA0B;AAC/G,MAAI;AACF,QAAI;AAAA,EACN,SAAS,OAAO;AACd,WAAO,MAAM,SAAS,GAAG,SAAS,KAAK;AAAA,EACzC;AACF;",
+  "names": []
+}

package/src/utils/toMaybe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toMaybe.d.ts","sourceRoot":"","sources":["../../../src/utils/toMaybe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,aAAa,CAAC;AAEvC,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,OAAO,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,CAAC,CAAuB,CAAC"}
+{"version":3,"file":"toMaybe.d.ts","sourceRoot":"","sources":["../../../src/utils/toMaybe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,aAAa,CAAC;AAEvC,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,OAAO,SAAS,CAAC,KAAG,KAAK,CAAC,CAAC,CAAuB,CAAC"}