tutuca 0.9.98 → 0.9.100

package/dist/tutuca-components.js

@@ -0,0 +1,2444 @@
+// src/components/data/data.js
+import { component as component3, html as html3, IMap as IMap2, ISet as ISet2, List as List2, OMap as OMap2, OrderedSet as OrderedSet2 } from "tutuca";
+
+// src/components/data/immutable-inspector.js
+import { component as component2, html as html2, IMap, ISet, List, OMap, OrderedSet, Record, Seq, Stack } from "tutuca";
+
+// src/components/data/json.js
+import { component, html } from "tutuca";
+var JsonNull = component({
+  name: "JsonNull",
+  fields: {},
+  view: html`<span
+    class="font-mono text-sm leading-tight text-warning italic"
+    >null</span
+  >`
+});
+var JsonBoolean = component({
+  name: "JsonBoolean",
+  fields: { value: false },
+  methods: {
+    text() {
+      return this.value ? "true" : "false";
+    },
+    cssClass() {
+      const base = "font-mono text-sm leading-tight";
+      return `${base} ${this.value ? "text-success" : "text-warning"}`;
+    }
+  },
+  view: html`<span :class="$cssClass" @text="$text"></span>`,
+  views: {
+    _margauiClasses: html`<p class="text-success text-warning"></p>`
+  }
+});
+var JsonNumber = component({
+  name: "JsonNumber",
+  fields: { value: 0 },
+  methods: {
+    text() {
+      return String(this.value);
+    }
+  },
+  view: html`<span
+    class="font-mono text-sm leading-tight text-info"
+    @text="$text"
+  ></span>`
+});
+var JsonString = component({
+  name: "JsonString",
+  fields: { value: "" },
+  methods: {
+    text() {
+      return JSON.stringify(this.value ?? "");
+    }
+  },
+  view: html`<span
+    class="font-mono text-sm leading-tight inline-block max-w-xs truncate align-bottom"
+    :title=".value"
+    @text="$text"
+  ></span>`
+});
+var compositeFields = {
+  items: [],
+  isExpanded: false,
+  itemsPerPage: 10,
+  currentPage: 0
+};
+var compositeMethods = {
+  arrowText() {
+    return this.isExpanded ? "▼" : "▶";
+  },
+  isItemsEmpty() {
+    return this.items.size === 0;
+  },
+  pageCount() {
+    return Math.max(1, Math.ceil(this.items.size / this.itemsPerPage));
+  },
+  pageStart() {
+    return this.currentPage * this.itemsPerPage;
+  },
+  pageEnd() {
+    return Math.min(this.items.size, this.pageStart() + this.itemsPerPage);
+  },
+  hasPagination() {
+    return this.items.size > this.itemsPerPage;
+  },
+  showPagination() {
+    return this.isExpanded && this.hasPagination();
+  },
+  cannotPrevPage() {
+    return this.currentPage <= 0;
+  },
+  cannotNextPage() {
+    return this.currentPage >= this.pageCount() - 1;
+  },
+  pageIndicatorText() {
+    return `${this.currentPage + 1} / ${this.pageCount()}`;
+  },
+  prevPage() {
+    return this.currentPage > 0 ? this.setCurrentPage(this.currentPage - 1) : this;
+  },
+  nextPage() {
+    return this.currentPage < this.pageCount() - 1 ? this.setCurrentPage(this.currentPage + 1) : this;
+  }
+};
+var compositeAlter = {
+  getPageRange() {
+    return { start: this.pageStart(), end: this.pageEnd() };
+  }
+};
+function makeCompositeView({
+  typeClass = "",
+  borderClass = "border-base-content/10",
+  toggleHandler = "$toggleIsExpanded"
+} = {}) {
+  return html`<span class="font-mono text-sm leading-tight inline-block">
+    <span class="inline-flex items-center gap-2">
+      <button
+        type="button"
+        class="cursor-pointer text-base-content/70 hover:text-base-content inline-flex items-center gap-1"
+        :disabled="$isItemsEmpty"
+        @on.click="${toggleHandler}"
+      >
+        <span @text="$arrowText"></span>
+        <span class="${typeClass}" @text="$typeText"></span>
+        <span @text="$countText"></span>
+      </button>
+      <div @show="$showPagination" class="join">
+        <button
+          type="button"
+          class="join-item btn btn-xs"
+          :disabled="$cannotPrevPage"
+          @on.click="$prevPage"
+        >
+          «
+        </button>
+        <span
+          class="join-item badge font-mono text-xs"
+          @text="$pageIndicatorText"
+        ></span>
+        <button
+          type="button"
+          class="join-item btn btn-xs"
+          :disabled="$cannotNextPage"
+          @on.click="$nextPage"
+        >
+          »
+        </button>
+      </div>
+    </span>
+    <div
+      @show=".isExpanded"
+      class="ml-1 flex flex-col gap-0.5 border-l ${borderClass} pl-2 mt-0.5"
+    >
+      <x render-each=".items" loop-with="getPageRange"></x>
+    </div>
+  </span>`;
+}
+var compositeView = makeCompositeView();
+var JsonArray = component({
+  name: "JsonArray",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "Array";
+    },
+    countText() {
+      return `(${this.items.size})`;
+    }
+  },
+  alter: compositeAlter,
+  view: compositeView
+});
+var JsonObject = component({
+  name: "JsonObject",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "Object";
+    },
+    countText() {
+      return `{${this.items.size}}`;
+    }
+  },
+  alter: compositeAlter,
+  view: compositeView
+});
+var JsonProperty = component({
+  name: "JsonProperty",
+  fields: {
+    key: "",
+    child: null
+  },
+  view: html`<div class="flex items-center gap-2 leading-tight">
+    <span class="text-base-content/60 font-mono text-sm" @text=".key"></span>
+    <span class="text-base-content/30">:</span>
+    <x render=".child"></x>
+  </div>`
+});
+var JsonViewer = component({
+  name: "JsonViewer",
+  fields: {
+    value: null
+  },
+  methods: {
+    toggleIsExpanded() {
+      return typeof this.value?.toggleIsExpanded === "function" ? this.setValue(this.value.toggleIsExpanded()) : this;
+    }
+  },
+  statics: {
+    fromData(data) {
+      return this.make({ value: classifyData(data) });
+    }
+  },
+  view: html`<span class="contents"><x render=".value"></x></span>`
+});
+function classifyJson(data, recurse = classifyJson) {
+  if (data === null || data === undefined)
+    return JsonNull.make({});
+  const t = typeof data;
+  if (t === "boolean")
+    return JsonBoolean.make({ value: data });
+  if (t === "number")
+    return JsonNumber.make({ value: data });
+  if (t === "string")
+    return JsonString.make({ value: data });
+  if (Array.isArray(data)) {
+    const items = data.map((v, i) => JsonProperty.make({ key: String(i), child: recurse(v) }));
+    return JsonArray.make({ items });
+  }
+  if (t === "object") {
+    const proto = Object.getPrototypeOf(data);
+    if (proto === Object.prototype || proto === null) {
+      const items = Object.entries(data).map(([k, v]) => JsonProperty.make({ key: k, child: recurse(v) }));
+      return JsonObject.make({ items });
+    }
+  }
+  return null;
+}
+function classifyData(data, recurse = classifyData) {
+  if (data === null || data === undefined)
+    return JsonNull.make({});
+  const t = typeof data;
+  if (t === "boolean")
+    return JsonBoolean.make({ value: data });
+  if (t === "number")
+    return JsonNumber.make({ value: data });
+  if (t === "string")
+    return JsonString.make({ value: data });
+  if (Array.isArray(data)) {
+    const items = data.map((v, i) => JsonProperty.make({ key: String(i), child: recurse(v) }));
+    return JsonArray.make({ items });
+  }
+  if (t === "object") {
+    const items = Object.entries(data).map(([k, v]) => JsonProperty.make({ key: k, child: recurse(v) }));
+    return JsonObject.make({ items });
+  }
+  return JsonNull.make({});
+}
+function chain(...classifiers) {
+  const recurse = (data) => {
+    for (const c of classifiers) {
+      const result = c(data, recurse);
+      if (result != null)
+        return result;
+    }
+    return null;
+  };
+  return recurse;
+}
+function getComponents() {
+  return [
+    JsonViewer,
+    JsonProperty,
+    JsonNull,
+    JsonBoolean,
+    JsonNumber,
+    JsonString,
+    JsonArray,
+    JsonObject
+  ];
+}
+
+// src/components/data/immutable-inspector.js
+var immutableContainerView = makeCompositeView({
+  typeClass: "text-accent",
+  borderClass: "border-accent"
+});
+function fmtMapKey(k) {
+  if (k === null || k === undefined)
+    return String(k);
+  const t = typeof k;
+  if (t === "string" || t === "number" || t === "boolean")
+    return String(k);
+  if (List.isList(k))
+    return `List[${k.size}]`;
+  if (OMap.isOrderedMap(k))
+    return `OrderedMap[${k.size}]`;
+  if (IMap.isMap(k))
+    return `Map[${k.size}]`;
+  if (OrderedSet.isOrderedSet(k))
+    return `OrderedSet[${k.size}]`;
+  if (ISet.isSet(k))
+    return `Set[${k.size}]`;
+  return String(k);
+}
+var ImEntry = component2({
+  name: "ImEntry",
+  fields: { key: "", child: null, showKey: true },
+  view: html2`<div class="flex items-center gap-2 leading-tight">
+    <span
+      @show=".showKey"
+      class="text-base-content/60 font-mono text-sm"
+      @text=".key"
+    ></span>
+    <span @show=".showKey" class="text-base-content/30">:</span>
+    <x render=".child"></x>
+  </div>`
+});
+var ImList = component2({
+  name: "ImList",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "List";
+    },
+    countText() {
+      return `[${this.items.size}]`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(list, recurse) {
+      const items = list.toArray().map((v, i) => ImEntry.make({ key: String(i), child: recurse(v) }));
+      return this.make({ items });
+    }
+  },
+  view: immutableContainerView
+});
+var ImStack = component2({
+  name: "ImStack",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "Stack";
+    },
+    countText() {
+      return `[${this.items.size}]`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(stack, recurse) {
+      const items = stack.toArray().map((v, i) => ImEntry.make({ key: String(i), child: recurse(v) }));
+      return this.make({ items });
+    }
+  },
+  view: immutableContainerView
+});
+var ImMap = component2({
+  name: "ImMap",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "Map";
+    },
+    countText() {
+      return `{${this.items.size}}`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(map, recurse) {
+      const items = [];
+      map.forEach((v, k) => {
+        items.push(ImEntry.make({ key: fmtMapKey(k), child: recurse(v) }));
+      });
+      return this.make({ items });
+    }
+  },
+  view: immutableContainerView
+});
+var ImOMap = component2({
+  name: "ImOMap",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "OrderedMap";
+    },
+    countText() {
+      return `{${this.items.size}}`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(map, recurse) {
+      const items = [];
+      map.forEach((v, k) => {
+        items.push(ImEntry.make({ key: fmtMapKey(k), child: recurse(v) }));
+      });
+      return this.make({ items });
+    }
+  },
+  view: immutableContainerView
+});
+var ImSet = component2({
+  name: "ImSet",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "Set";
+    },
+    countText() {
+      return `{${this.items.size}}`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(set, recurse) {
+      const items = set.toArray().map((v) => ImEntry.make({ key: "", showKey: false, child: recurse(v) }));
+      return this.make({ items });
+    }
+  },
+  view: immutableContainerView
+});
+var ImOSet = component2({
+  name: "ImOSet",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "OrderedSet";
+    },
+    countText() {
+      return `{${this.items.size}}`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(set, recurse) {
+      const items = set.toArray().map((v) => ImEntry.make({ key: "", showKey: false, child: recurse(v) }));
+      return this.make({ items });
+    }
+  },
+  view: immutableContainerView
+});
+var ImRecord = component2({
+  name: "ImRecord",
+  fields: { ...compositeFields, recordName: "" },
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return this.recordName ? `Record ${this.recordName}` : "Record";
+    },
+    countText() {
+      return `{${this.items.size}}`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(rec, recurse) {
+      const recordName = rec._name || rec.constructor.name || "Record";
+      const items = [];
+      rec.toSeq().forEach((v, k) => {
+        items.push(ImEntry.make({ key: String(k), child: recurse(v) }));
+      });
+      return this.make({ recordName, items });
+    }
+  },
+  view: immutableContainerView
+});
+var ImRange = component2({
+  name: "ImRange",
+  fields: { rangeText: "" },
+  statics: {
+    fromData(seq) {
+      const { _start: start, _end: end, _step: step } = seq;
+      const rangeText = step === 1 ? `${start}…${end}` : `${start}…${end} by ${step}`;
+      return this.make({ rangeText });
+    }
+  },
+  view: html2`<span
+    class="font-mono text-sm leading-tight inline-flex items-center gap-1"
+  >
+    <span class="font-mono text-accent">Range</span>
+    <span class="text-base-content/70" @text=".rangeText"></span>
+  </span>`
+});
+var ImInspector = component2({
+  name: "ImInspector",
+  fields: { value: null },
+  methods: {
+    toggleIsExpanded() {
+      return typeof this.value?.toggleIsExpanded === "function" ? this.setValue(this.value.toggleIsExpanded()) : this;
+    }
+  },
+  statics: {
+    fromData(data) {
+      return this.make({ value: dispatch(data) });
+    }
+  },
+  view: html2`<span class="contents"><x render=".value"></x></span>`
+});
+function classifyImmutable(data, recurse) {
+  if (Seq.isSeq(data) && data._start !== undefined && data._end !== undefined && data._step !== undefined) {
+    return ImRange.Class.fromData(data, recurse);
+  }
+  if (Record.isRecord(data))
+    return ImRecord.Class.fromData(data, recurse);
+  if (List.isList(data))
+    return ImList.Class.fromData(data, recurse);
+  if (Stack.isStack(data))
+    return ImStack.Class.fromData(data, recurse);
+  if (OMap.isOrderedMap(data))
+    return ImOMap.Class.fromData(data, recurse);
+  if (IMap.isMap(data))
+    return ImMap.Class.fromData(data, recurse);
+  if (OrderedSet.isOrderedSet(data))
+    return ImOSet.Class.fromData(data, recurse);
+  if (ISet.isSet(data))
+    return ImSet.Class.fromData(data, recurse);
+  return null;
+}
+var dispatch = chain(classifyImmutable, classifyData);
+function getComponents2() {
+  return [
+    ImInspector,
+    ImEntry,
+    ImList,
+    ImStack,
+    ImMap,
+    ImOMap,
+    ImSet,
+    ImOSet,
+    ImRecord,
+    ImRange,
+    ...getComponents()
+  ];
+}
+
+// src/components/data/data.js
+var JsUndefined = component3({
+  name: "JsUndefined",
+  fields: {},
+  view: html3`<span
+    class="font-mono text-sm leading-tight text-warning italic"
+    >undefined</span
+  >`
+});
+var JsBigInt = component3({
+  name: "JsBigInt",
+  fields: { value: "" },
+  methods: {
+    text() {
+      return `${this.value}n`;
+    }
+  },
+  view: html3`<span
+    class="font-mono text-sm leading-tight text-info"
+    @text="$text"
+  ></span>`
+});
+var JsSymbol = component3({
+  name: "JsSymbol",
+  fields: { description: "" },
+  view: html3`<span class="font-mono text-sm leading-tight"
+    ><span class="text-info">Symbol</span
+    ><span class="text-base-content/40">: </span
+    ><span @text=".description"></span
+  ></span>`
+});
+var JsFunction = component3({
+  name: "JsFunction",
+  fields: { name: "", kind: "function" },
+  methods: {
+    hasIdentifier() {
+      return this.kind !== "arrow" && this.name !== "";
+    },
+    prefixText() {
+      if (this.kind === "arrow")
+        return "() => { … }";
+      if (this.kind === "class")
+        return this.name ? "class " : "class { … }";
+      return this.name ? "function " : "function () { … }";
+    },
+    suffixText() {
+      if (this.kind === "class")
+        return " { … }";
+      return "() { … }";
+    }
+  },
+  view: html3`<span class="font-mono text-sm leading-tight"
+    ><span class="text-base-content/40" @text="$prefixText"></span
+    ><span
+      class="text-info"
+      @show="$hasIdentifier"
+      @text=".name"
+    ></span
+    ><span
+      class="text-base-content/40"
+      @show="$hasIdentifier"
+      @text="$suffixText"
+    ></span
+  ></span>`
+});
+var JsDate = component3({
+  name: "JsDate",
+  fields: { value: "" },
+  view: html3`<span class="font-mono text-sm leading-tight"
+    ><span class="text-info">Date</span
+    ><span class="text-base-content/40">: </span
+    ><span @text=".value"></span
+  ></span>`
+});
+var JsRegExp = component3({
+  name: "JsRegExp",
+  fields: { value: "" },
+  view: html3`<span
+    class="font-mono text-sm leading-tight text-error"
+    @text=".value"
+  ></span>`
+});
+var JsError = component3({
+  name: "JsError",
+  fields: { errorName: "Error", message: "" },
+  view: html3`<span class="font-mono text-sm leading-tight"
+    ><span class="text-info" @text=".errorName"></span
+    ><span class="text-base-content/40">: </span
+    ><span
+      class="inline-block max-w-xs truncate align-bottom"
+      :title=".message"
+      @text=".message"
+    ></span
+  ></span>`
+});
+var JsSetItem = component3({
+  name: "JsSetItem",
+  fields: { child: null },
+  view: html3`<div class="flex items-center gap-2 leading-tight">
+    <x render=".child"></x>
+  </div>`
+});
+function fmtAnyKey(k) {
+  if (k === null)
+    return "null";
+  if (k === undefined)
+    return "undefined";
+  const t = typeof k;
+  if (t === "string" || t === "number" || t === "boolean" || t === "bigint")
+    return String(k);
+  if (t === "symbol")
+    return String(k);
+  if (t === "function")
+    return `ƒ ${k.name || "(anonymous)"}()`;
+  if (Array.isArray(k))
+    return `Array(${k.length})`;
+  if (k instanceof Map)
+    return `Map(${k.size})`;
+  if (k instanceof Set)
+    return `Set(${k.size})`;
+  if (k instanceof Date)
+    return k.toISOString();
+  if (List2.isList(k))
+    return `List[${k.size}]`;
+  if (OMap2.isOrderedMap(k))
+    return `OrderedMap[${k.size}]`;
+  if (IMap2.isMap(k))
+    return `Map[${k.size}]`;
+  if (OrderedSet2.isOrderedSet(k))
+    return `OrderedSet[${k.size}]`;
+  if (ISet2.isSet(k))
+    return `Set[${k.size}]`;
+  const ctor = k.constructor?.name;
+  return ctor && ctor !== "Object" ? `${ctor} {…}` : Object.prototype.toString.call(k);
+}
+var JsMap = component3({
+  name: "JsMap",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "Map";
+    },
+    countText() {
+      return `(${this.items.size})`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(map, recurse) {
+      const items = [];
+      map.forEach((v, k) => {
+        items.push(JsonProperty.make({ key: fmtAnyKey(k), child: recurse(v) }));
+      });
+      return this.make({ items });
+    }
+  },
+  view: compositeView
+});
+var JsSet = component3({
+  name: "JsSet",
+  fields: compositeFields,
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return "Set";
+    },
+    countText() {
+      return `(${this.items.size})`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(set, recurse) {
+      const items = [...set].map((v) => JsSetItem.make({ child: recurse(v) }));
+      return this.make({ items });
+    }
+  },
+  view: compositeView
+});
+var JsClassInstance = component3({
+  name: "JsClassInstance",
+  fields: { ...compositeFields, className: "Object" },
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return this.className;
+    },
+    countText() {
+      return `{${this.items.size}}`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(obj, recurse) {
+      const className = obj.constructor?.name || "Object";
+      const items = [];
+      try {
+        for (const [k, v] of Object.entries(obj)) {
+          items.push(JsonProperty.make({ key: k, child: recurse(v) }));
+        }
+      } catch (_e) {}
+      return this.make({ className, items });
+    }
+  },
+  view: compositeView
+});
+function classifyJsExtra(data, recurse) {
+  if (data === undefined)
+    return JsUndefined.make({});
+  const t = typeof data;
+  if (t === "symbol")
+    return JsSymbol.make({ description: data.description ?? "" });
+  if (t === "function") {
+    let kind = "function";
+    const src = String(data);
+    if (/^(?:async\s+)?class\s/.test(src))
+      kind = "class";
+    else if (!/^(?:async\s+)?function\b/.test(src) && /=>/.test(src))
+      kind = "arrow";
+    return JsFunction.make({ name: data.name ?? "", kind });
+  }
+  if (t === "bigint")
+    return JsBigInt.make({ value: String(data) });
+  if (t !== "object" || data === null)
+    return null;
+  if (data instanceof Date)
+    return JsDate.make({ value: data.toISOString() });
+  if (data instanceof RegExp)
+    return JsRegExp.make({ value: String(data) });
+  if (data instanceof Error)
+    return JsError.make({
+      errorName: data.name ?? "Error",
+      message: data.message ?? ""
+    });
+  if (data instanceof Map)
+    return JsMap.Class.fromData(data, recurse);
+  if (data instanceof Set)
+    return JsSet.Class.fromData(data, recurse);
+  const proto = Object.getPrototypeOf(data);
+  if (proto !== Object.prototype && proto !== null) {
+    return JsClassInstance.Class.fromData(data, recurse);
+  }
+  return null;
+}
+var dispatch2 = chain(classifyImmutable, classifyJsExtra, classifyJson);
+var DataInspector = component3({
+  name: "DataInspector",
+  fields: { value: null },
+  methods: {
+    toggleIsExpanded() {
+      return typeof this.value?.toggleIsExpanded === "function" ? this.setValue(this.value.toggleIsExpanded()) : this;
+    }
+  },
+  statics: {
+    fromData(data) {
+      return this.make({ value: dispatch2(data) });
+    }
+  },
+  view: html3`<span class="contents"><x render=".value"></x></span>`
+});
+function getComponents3() {
+  return [
+    DataInspector,
+    JsUndefined,
+    JsBigInt,
+    JsSymbol,
+    JsFunction,
+    JsDate,
+    JsRegExp,
+    JsError,
+    JsMap,
+    JsSet,
+    JsClassInstance,
+    JsSetItem,
+    ...getComponents2()
+  ];
+}
+
+// src/components/data/json-schema.js
+import { component as component4, html as html4 } from "tutuca";
+var schemaNodeFields = {
+  ...compositeFields,
+  typeLabel: "",
+  badges: [],
+  title: "",
+  description: "",
+  deprecated: false
+};
+function schemaNodeMethods(extra = {}) {
+  return {
+    ...compositeMethods,
+    typeText() {
+      return this.typeLabel;
+    },
+    ...extra
+  };
+}
+var GRID_BODY = html4`<div
+  @show=".isExpanded"
+  class="ml-1 grid gap-x-2 gap-y-0.5 items-baseline border-l border-base-content/10 pl-2 mt-0.5"
+  style="grid-template-columns: auto 1fr"
+>
+  <x render-each=".items" loop-with="getPageRange"></x>
+</div>`;
+var LIST_BODY = html4`<div
+  @show=".isExpanded"
+  class="ml-1 flex flex-col gap-0.5 border-l border-base-content/10 pl-2 mt-0.5"
+>
+  <x render-each=".items" loop-with="getPageRange"></x>
+</div>`;
+function makeSchemaView(accent, body = GRID_BODY) {
+  return html4`<span class="font-mono text-sm leading-tight inline-block">
+    <span class="inline-flex items-center gap-2 flex-wrap">
+      <button
+        type="button"
+        class="cursor-pointer text-base-content/70 hover:text-base-content inline-flex items-center gap-1"
+        :disabled="$isItemsEmpty"
+        @on.click="$toggleIsExpanded"
+      >
+        <span @hide="$isItemsEmpty" @text="$arrowText"></span>
+        <span class="${accent} font-semibold" @text="$typeText"></span>
+        <span class="text-base-content/50" @text="$countText"></span>
+      </button>
+      <span
+        @each=".badges"
+        class="badge badge-xs badge-ghost font-mono font-normal"
+        ><x text="@value"></x
+      ></span>
+      <span @show=".deprecated" class="badge badge-xs badge-warning"
+        >deprecated</span
+      >
+      <div @show="$showPagination" class="join">
+        <button
+          type="button"
+          class="join-item btn btn-xs"
+          :disabled="$cannotPrevPage"
+          @on.click="$prevPage"
+        >
+          «
+        </button>
+        <span
+          class="join-item badge font-mono text-xs"
+          @text="$pageIndicatorText"
+        ></span>
+        <button
+          type="button"
+          class="join-item btn btn-xs"
+          :disabled="$cannotNextPage"
+          @on.click="$nextPage"
+        >
+          »
+        </button>
+      </div>
+    </span>
+    <span
+      @show="truthy? .title"
+      class="block text-base-content/80 italic"
+      @text=".title"
+    ></span>
+    <span
+      @show="truthy? .description"
+      class="block text-base-content/50"
+      @text=".description"
+    ></span>
+    ${body}
+  </span>`;
+}
+function metaOf(schema) {
+  return {
+    title: typeof schema.title === "string" ? schema.title : "",
+    description: typeof schema.description === "string" ? schema.description : "",
+    deprecated: schema.deprecated === true
+  };
+}
+function displayType(schema, fallback) {
+  const t = schema.type;
+  if (Array.isArray(t))
+    return t.join(" | ");
+  if (typeof t === "string")
+    return t;
+  return fallback;
+}
+function simpleScalarType(schema) {
+  if (schema == null || typeof schema !== "object")
+    return null;
+  const t = schema.type;
+  const typeOk = typeof t === "string" || Array.isArray(t) && t.every((x) => typeof x === "string");
+  if (!typeOk)
+    return null;
+  if (Object.keys(schema).some((k) => k !== "type"))
+    return null;
+  return Array.isArray(t) ? t.join(" | ") : t;
+}
+function combinatorPhrasing(kind) {
+  if (kind === "allOf")
+    return "all of";
+  if (kind === "anyOf")
+    return "any of";
+  if (kind === "oneOf")
+    return "one of";
+  return "combination";
+}
+function collectBadges(schema) {
+  const b = [];
+  if (schema.format != null)
+    b.push(`format: ${schema.format}`);
+  if (schema.minLength != null)
+    b.push(`min length: ${schema.minLength}`);
+  if (schema.maxLength != null)
+    b.push(`max length: ${schema.maxLength}`);
+  if (schema.pattern != null)
+    b.push(`pattern: /${schema.pattern}/`);
+  if (schema.minimum != null)
+    b.push(`≥ ${schema.minimum}`);
+  if (schema.maximum != null)
+    b.push(`≤ ${schema.maximum}`);
+  if (schema.exclusiveMinimum != null)
+    b.push(`> ${schema.exclusiveMinimum}`);
+  if (schema.exclusiveMaximum != null)
+    b.push(`< ${schema.exclusiveMaximum}`);
+  if (schema.multipleOf != null)
+    b.push(`multiple of ${schema.multipleOf}`);
+  if (schema.minItems != null)
+    b.push(`min items: ${schema.minItems}`);
+  if (schema.maxItems != null)
+    b.push(`max items: ${schema.maxItems}`);
+  if (schema.uniqueItems)
+    b.push("unique items");
+  if (schema.minProperties != null)
+    b.push(`min properties: ${schema.minProperties}`);
+  if (schema.maxProperties != null)
+    b.push(`max properties: ${schema.maxProperties}`);
+  if (schema.additionalProperties === false)
+    b.push("no additional properties");
+  if (schema.readOnly)
+    b.push("read-only");
+  if (schema.writeOnly)
+    b.push("write-only");
+  return b;
+}
+function valueBranch(label, value) {
+  return SchemaBranch.make({
+    label,
+    child: JsonViewer.Class.fromData(value),
+    labelClass: "text-info"
+  });
+}
+function collectExtras(schema, recurse, primary) {
+  const rows = [];
+  if (primary !== "const" && "const" in schema)
+    rows.push(valueBranch("const", schema.const));
+  if (primary !== "enum" && Array.isArray(schema.enum))
+    rows.push(valueBranch("enum", schema.enum));
+  if ("default" in schema)
+    rows.push(valueBranch("default", schema.default));
+  if ("examples" in schema)
+    rows.push(valueBranch("examples", schema.examples));
+  if (primary !== "combinator") {
+    for (const k of ["allOf", "anyOf", "oneOf"]) {
+      if (Array.isArray(schema[k])) {
+        for (const s of schema[k]) {
+          rows.push(SchemaBranch.make({
+            label: combinatorPhrasing(k),
+            child: recurse(s),
+            labelClass: "text-accent"
+          }));
+        }
+      }
+    }
+  }
+  if (primary !== "not" && schema.not !== undefined) {
+    rows.push(SchemaBranch.make({
+      label: "not",
+      child: recurse(schema.not),
+      labelClass: "text-error"
+    }));
+  }
+  if (primary !== "conditional") {
+    if (schema.if !== undefined)
+      rows.push(SchemaBranch.make({ label: "if", child: recurse(schema.if) }));
+    if (schema.then !== undefined)
+      rows.push(SchemaBranch.make({ label: "then", child: recurse(schema.then) }));
+    if (schema.else !== undefined)
+      rows.push(SchemaBranch.make({ label: "else", child: recurse(schema.else) }));
+  }
+  const defs = schema.$defs || schema.definitions;
+  if (defs && typeof defs === "object") {
+    for (const [name, s] of Object.entries(defs)) {
+      rows.push(SchemaBranch.make({
+        label: `$defs/${name}`,
+        child: recurse(s),
+        labelClass: "text-secondary"
+      }));
+    }
+  }
+  return rows;
+}
+var SchemaProperty = component4({
+  name: "SchemaProperty",
+  fields: { key: "", child: null, required: false },
+  view: html4`<div class="contents">
+    <span class="font-mono text-sm flex items-center gap-1 leading-tight">
+      <span class="text-base-content/60" @text=".key"></span>
+      <span @show=".required" class="text-error font-bold" title="required"
+        >*</span
+      >
+      <span class="text-base-content/30">:</span>
+    </span>
+    <x render=".child"></x>
+  </div>`
+});
+var SchemaBranch = component4({
+  name: "SchemaBranch",
+  fields: { label: "", child: null, labelClass: "text-accent" },
+  methods: {
+    labelCssClass() {
+      return `font-mono text-sm ${this.labelClass}`;
+    }
+  },
+  view: html4`<div class="contents">
+    <span class="flex items-center gap-1 leading-tight">
+      <span :class="$labelCssClass" @text=".label"></span>
+      <span class="text-base-content/30">:</span>
+    </span>
+    <x render=".child"></x>
+  </div>`,
+  views: {
+    _margauiClasses: html4`<p
+      class="text-accent text-secondary text-info text-error"
+    ></p>`
+  }
+});
+var SchemaScalar = component4({
+  name: "SchemaScalar",
+  fields: schemaNodeFields,
+  methods: schemaNodeMethods({
+    countText() {
+      return "";
+    }
+  }),
+  alter: compositeAlter,
+  statics: {
+    fromData(schema, recurse) {
+      return this.make({
+        typeLabel: displayType(schema, "any"),
+        badges: collectBadges(schema),
+        ...metaOf(schema),
+        items: collectExtras(schema, recurse, "scalar")
+      });
+    }
+  },
+  view: makeSchemaView("text-success")
+});
+var SchemaObject = component4({
+  name: "SchemaObject",
+  fields: schemaNodeFields,
+  methods: schemaNodeMethods({
+    countText() {
+      return this.items.size > 0 ? `{${this.items.size}}` : "";
+    }
+  }),
+  alter: compositeAlter,
+  statics: {
+    fromData(schema, recurse) {
+      const required = Array.isArray(schema.required) ? schema.required : [];
+      const items = [];
+      if (schema.properties && typeof schema.properties === "object") {
+        for (const [k, v] of Object.entries(schema.properties)) {
+          items.push(SchemaProperty.make({
+            key: k,
+            required: required.includes(k),
+            child: recurse(v)
+          }));
+        }
+      }
+      if (schema.patternProperties && typeof schema.patternProperties === "object") {
+        for (const [pat, v] of Object.entries(schema.patternProperties)) {
+          items.push(SchemaBranch.make({
+            label: `/${pat}/`,
+            child: recurse(v),
+            labelClass: "text-secondary"
+          }));
+        }
+      }
+      if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+        items.push(SchemaBranch.make({
+          label: "additional properties",
+          child: recurse(schema.additionalProperties),
+          labelClass: "text-secondary"
+        }));
+      }
+      if (schema.propertyNames !== undefined) {
+        items.push(SchemaBranch.make({
+          label: "property names",
+          child: recurse(schema.propertyNames),
+          labelClass: "text-secondary"
+        }));
+      }
+      items.push(...collectExtras(schema, recurse, "object"));
+      return this.make({
+        typeLabel: displayType(schema, "object"),
+        badges: collectBadges(schema),
+        ...metaOf(schema),
+        items
+      });
+    }
+  },
+  view: makeSchemaView("text-primary")
+});
+var SchemaArray = component4({
+  name: "SchemaArray",
+  fields: schemaNodeFields,
+  methods: schemaNodeMethods({
+    countText() {
+      return this.items.size > 0 ? `[${this.items.size}]` : "";
+    }
+  }),
+  alter: compositeAlter,
+  statics: {
+    fromData(schema, recurse) {
+      const items = [];
+      const isTuple = Array.isArray(schema.prefixItems);
+      const inlineType = !isTuple && !Array.isArray(schema.items) ? simpleScalarType(schema.items) : null;
+      if (isTuple) {
+        schema.prefixItems.forEach((s, i) => {
+          items.push(SchemaBranch.make({ label: `item ${i}`, child: recurse(s) }));
+        });
+      }
+      if (Array.isArray(schema.items)) {
+        schema.items.forEach((s, i) => {
+          items.push(SchemaBranch.make({ label: `item ${i}`, child: recurse(s) }));
+        });
+      } else if (schema.items !== undefined && inlineType == null) {
+        items.push(SchemaBranch.make({ label: "items", child: recurse(schema.items) }));
+      }
+      if (schema.contains !== undefined) {
+        items.push(SchemaBranch.make({
+          label: "contains",
+          child: recurse(schema.contains)
+        }));
+      }
+      items.push(...collectExtras(schema, recurse, "array"));
+      const typeLabel = isTuple ? "tuple" : inlineType != null ? `array of ${inlineType}` : displayType(schema, "array");
+      return this.make({
+        typeLabel,
+        badges: collectBadges(schema),
+        ...metaOf(schema),
+        items
+      });
+    }
+  },
+  view: makeSchemaView("text-primary")
+});
+var SchemaEnum = component4({
+  name: "SchemaEnum",
+  fields: schemaNodeFields,
+  methods: schemaNodeMethods({
+    countText() {
+      return this.items.size > 0 ? `(${this.items.size})` : "";
+    }
+  }),
+  alter: compositeAlter,
+  statics: {
+    fromData(schema, recurse) {
+      const members = Array.isArray(schema.enum) ? schema.enum : [];
+      const items = members.map((v) => JsonViewer.Class.fromData(v));
+      items.push(...collectExtras(schema, recurse, "enum"));
+      return this.make({
+        typeLabel: "enum",
+        badges: collectBadges(schema),
+        ...metaOf(schema),
+        items
+      });
+    }
+  },
+  view: makeSchemaView("text-info", LIST_BODY)
+});
+var SchemaConst = component4({
+  name: "SchemaConst",
+  fields: { value: null },
+  statics: {
+    fromData(schema) {
+      return this.make({ value: JsonViewer.Class.fromData(schema.const) });
+    }
+  },
+  view: html4`<span
+    class="font-mono text-sm leading-tight inline-flex items-center gap-2"
+  >
+    <span class="text-info font-semibold">const</span>
+    <span class="text-base-content/30">=</span>
+    <x render=".value"></x>
+  </span>`
+});
+var SchemaCombinator = component4({
+  name: "SchemaCombinator",
+  fields: schemaNodeFields,
+  methods: schemaNodeMethods({
+    countText() {
+      return this.items.size > 0 ? `(${this.items.size})` : "";
+    }
+  }),
+  alter: compositeAlter,
+  statics: {
+    fromData(schema, recurse) {
+      const items = [];
+      let kind = null;
+      for (const k of ["allOf", "anyOf", "oneOf"]) {
+        if (Array.isArray(schema[k])) {
+          kind = kind ?? k;
+          for (const s of schema[k])
+            items.push(recurse(s));
+        }
+      }
+      items.push(...collectExtras(schema, recurse, "combinator"));
+      return this.make({
+        typeLabel: combinatorPhrasing(kind),
+        badges: collectBadges(schema),
+        ...metaOf(schema),
+        items
+      });
+    }
+  },
+  view: makeSchemaView("text-accent", LIST_BODY)
+});
+var SchemaConditional = component4({
+  name: "SchemaConditional",
+  fields: {
+    ifNode: null,
+    thenNode: null,
+    elseNode: null,
+    title: "",
+    description: "",
+    deprecated: false
+  },
+  statics: {
+    fromData(schema, recurse) {
+      return this.make({
+        ifNode: schema.if !== undefined ? recurse(schema.if) : null,
+        thenNode: schema.then !== undefined ? recurse(schema.then) : null,
+        elseNode: schema.else !== undefined ? recurse(schema.else) : null,
+        ...metaOf(schema)
+      });
+    }
+  },
+  view: html4`<span class="font-mono text-sm leading-tight inline-block">
+    <span class="inline-flex items-center gap-2 flex-wrap">
+      <span class="text-accent font-semibold">conditional</span>
+      <span @show=".deprecated" class="badge badge-xs badge-warning"
+        >deprecated</span
+      >
+    </span>
+    <span
+      @show="truthy? .title"
+      class="block text-base-content/80 italic"
+      @text=".title"
+    ></span>
+    <span
+      @show="truthy? .description"
+      class="block text-base-content/50"
+      @text=".description"
+    ></span>
+    <div
+      class="ml-1 grid gap-x-2 gap-y-0.5 items-baseline border-l border-base-content/10 pl-2 mt-0.5"
+      style="grid-template-columns: auto 1fr"
+    >
+      <div @show="truthy? .ifNode" class="contents">
+        <span class="font-mono text-sm flex items-center gap-1 leading-tight">
+          <span class="text-info">if</span>
+          <span class="text-base-content/30">:</span>
+        </span>
+        <x render=".ifNode"></x>
+      </div>
+      <div @show="truthy? .thenNode" class="contents">
+        <span class="font-mono text-sm flex items-center gap-1 leading-tight">
+          <span class="text-success">then</span>
+          <span class="text-base-content/30">:</span>
+        </span>
+        <x render=".thenNode"></x>
+      </div>
+      <div @show="truthy? .elseNode" class="contents">
+        <span class="font-mono text-sm flex items-center gap-1 leading-tight">
+          <span class="text-warning">else</span>
+          <span class="text-base-content/30">:</span>
+        </span>
+        <x render=".elseNode"></x>
+      </div>
+    </div>
+  </span>`
+});
+var SchemaNot = component4({
+  name: "SchemaNot",
+  fields: { child: null },
+  statics: {
+    fromData(schema, recurse) {
+      return this.make({ child: recurse(schema.not) });
+    }
+  },
+  view: html4`<span
+    class="font-mono text-sm leading-tight inline-flex items-center gap-2"
+  >
+    <span class="text-error font-semibold">not</span>
+    <span class="text-base-content/30">:</span>
+    <x render=".child"></x>
+  </span>`
+});
+var SchemaBoolean = component4({
+  name: "SchemaBoolean",
+  fields: { value: true },
+  methods: {
+    text() {
+      return this.value ? "any value (true)" : "no value allowed (false)";
+    },
+    cssClass() {
+      const base = "font-mono text-sm leading-tight italic";
+      return `${base} ${this.value ? "text-success" : "text-error"}`;
+    }
+  },
+  view: html4`<span :class="$cssClass" @text="$text"></span>`,
+  views: {
+    _margauiClasses: html4`<p class="text-success text-error"></p>`
+  }
+});
+var SchemaRef = component4({
+  name: "SchemaRef",
+  fields: { target: "" },
+  view: html4`<span class="font-mono text-sm leading-tight text-secondary"
+    >→ <span @text=".target"></span
+  ></span>`
+});
+var SchemaViewer = component4({
+  name: "SchemaViewer",
+  fields: {
+    value: null,
+    raw: null,
+    rawSchema: null,
+    showRaw: false
+  },
+  methods: {
+    toggleIsExpanded() {
+      return typeof this.value?.toggleIsExpanded === "function" ? this.setValue(this.value.toggleIsExpanded()) : this;
+    },
+    toggleLabel() {
+      return this.showRaw ? "high-level view" : "raw schema";
+    }
+  },
+  statics: {
+    fromData(schema) {
+      return this.make({
+        value: dispatch3(schema),
+        raw: JsonViewer.Class.fromData(schema),
+        rawSchema: schema
+      });
+    }
+  },
+  view: html4`<div class="inline-flex flex-col items-start gap-1">
+    <button
+      type="button"
+      class="btn btn-xs btn-ghost self-end"
+      @on.click="$toggleShowRaw"
+      @text="$toggleLabel"
+    ></button>
+    <x render=".value" hide=".showRaw"></x>
+    <x render=".raw" show=".showRaw"></x>
+  </div>`
+});
+function hasObjectKeywords(schema) {
+  const t = schema.type;
+  if (t === "object" || Array.isArray(t) && t.includes("object"))
+    return true;
+  return schema.properties !== undefined || schema.required !== undefined || schema.patternProperties !== undefined || schema.propertyNames !== undefined || schema.additionalProperties !== undefined || schema.minProperties != null || schema.maxProperties != null;
+}
+function hasArrayKeywords(schema) {
+  const t = schema.type;
+  if (t === "array" || Array.isArray(t) && t.includes("array"))
+    return true;
+  return schema.items !== undefined || schema.prefixItems !== undefined || schema.contains !== undefined || schema.minItems != null || schema.maxItems != null || schema.uniqueItems !== undefined;
+}
+function classifySchema(schema, recurse = classifySchema) {
+  if (schema === true || schema === false)
+    return SchemaBoolean.make({ value: schema });
+  if (schema === null || typeof schema !== "object")
+    return JsonViewer.Class.fromData(schema);
+  if (typeof schema.$ref === "string")
+    return SchemaRef.make({ target: schema.$ref });
+  if (hasObjectKeywords(schema))
+    return SchemaObject.Class.fromData(schema, recurse);
+  if (hasArrayKeywords(schema))
+    return SchemaArray.Class.fromData(schema, recurse);
+  if (Array.isArray(schema.enum))
+    return SchemaEnum.Class.fromData(schema, recurse);
+  if ("const" in schema)
+    return SchemaConst.Class.fromData(schema, recurse);
+  if (schema.allOf || schema.anyOf || schema.oneOf)
+    return SchemaCombinator.Class.fromData(schema, recurse);
+  if (schema.not !== undefined)
+    return SchemaNot.Class.fromData(schema, recurse);
+  if (schema.if !== undefined || schema.then !== undefined || schema.else !== undefined)
+    return SchemaConditional.Class.fromData(schema, recurse);
+  return SchemaScalar.Class.fromData(schema, recurse);
+}
+var dispatch3 = chain(classifySchema);
+function getComponents4() {
+  return [
+    SchemaViewer,
+    SchemaScalar,
+    SchemaObject,
+    SchemaArray,
+    SchemaEnum,
+    SchemaConst,
+    SchemaCombinator,
+    SchemaConditional,
+    SchemaNot,
+    SchemaProperty,
+    SchemaBranch,
+    SchemaBoolean,
+    SchemaRef,
+    ...getComponents()
+  ];
+}
+
+// src/components/tutuca/component-inspector.js
+import { component as component5, html as html5 } from "tutuca";
+function introspectComponent(comp) {
+  const { fields, methods } = comp.Class.getMetaClass();
+  return {
+    name: comp.name,
+    id: comp.id,
+    fields: Object.entries(fields).map(([name, f]) => ({
+      name,
+      type: f.type,
+      defaultValue: f.defaultValue
+    })),
+    methods: Object.keys(methods),
+    input: Object.keys(comp.input ?? {}),
+    receive: Object.keys(comp.receive ?? {}),
+    bubble: Object.keys(comp.bubble ?? {}),
+    response: Object.keys(comp.response ?? {}),
+    alter: Object.keys(comp.alter ?? {}),
+    statics: Object.keys(comp.spec?.statics ?? {}),
+    views: Object.values(comp.views ?? {}).map((v) => ({
+      name: v.name,
+      rawView: v.rawView
+    }))
+  };
+}
+var sectionView = makeCompositeView({
+  typeClass: "font-semibold",
+  borderClass: "border-base-content/15",
+  toggleHandler: "toggle isCtrl"
+});
+var CompName = component5({
+  name: "CompName",
+  fields: { name: "" },
+  view: html5`<span
+    class="font-mono text-sm leading-tight badge badge-sm badge-ghost"
+    @text=".name"
+  ></span>`
+});
+var CompField = component5({
+  name: "CompField",
+  fields: { name: "", typeName: "", child: null },
+  view: html5`<div class="flex items-center gap-2 leading-tight">
+    <span class="text-base-content/70 font-mono text-sm" @text=".name"></span>
+    <span class="text-base-content/30">:</span>
+    <span class="text-base-content/50 font-mono text-xs" @text=".typeName"></span>
+    <span class="text-base-content/30">=</span>
+    <x render=".child"></x>
+  </div>`
+});
+var CompView = component5({
+  name: "CompView",
+  fields: { name: "", rawView: "", isExpanded: false },
+  methods: {
+    arrowText() {
+      return this.isExpanded ? "▼" : "▶";
+    }
+  },
+  input: {
+    toggle(isCtrl, ctx) {
+      if (isCtrl) {
+        ctx.bubble("toggleAllViews", [!this.isExpanded]);
+        return this;
+      }
+      return this.toggleIsExpanded();
+    }
+  },
+  view: html5`<div class="flex flex-col gap-0.5 leading-tight">
+    <button
+      type="button"
+      class="cursor-pointer text-base-content/70 hover:text-base-content inline-flex items-center gap-1 self-start"
+      @on.click="toggle isCtrl"
+    >
+      <span @text="$arrowText"></span>
+      <span class="font-mono text-sm" @text=".name"></span>
+    </button>
+    <pre
+      @show=".isExpanded"
+      class="text-xs bg-base-200 rounded p-2 overflow-x-auto whitespace-pre-wrap"
+    ><code @text=".rawView"></code></pre>
+  </div>`
+});
+var CompSection = component5({
+  name: "CompSection",
+  fields: { ...compositeFields, label: "" },
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return this.label;
+    },
+    countText() {
+      return `(${this.items.size})`;
+    }
+  },
+  input: {
+    toggle(isCtrl, ctx) {
+      if (isCtrl) {
+        ctx.bubble("toggleAllSections", [!this.isExpanded]);
+        return this;
+      }
+      return this.toggleIsExpanded();
+    }
+  },
+  alter: compositeAlter,
+  view: sectionView
+});
+var ComponentInspector = component5({
+  name: "ComponentInspector",
+  fields: { compName: "", compId: 0, sections: [] },
+  methods: {
+    idText() {
+      return `#${this.compId}`;
+    },
+    setAllSections(state) {
+      return this.setSections(this.sections.map((s) => s.setIsExpanded(state)));
+    },
+    expandAll() {
+      return this.setAllSections(true);
+    },
+    collapseAll() {
+      return this.setAllSections(false);
+    },
+    setAllViews(state) {
+      return this.setSections(this.sections.map((s) => s.label === "Views" ? s.setItems(s.items.map((v) => v.setIsExpanded(state))) : s));
+    },
+    expandAllViews() {
+      return this.setAllViews(true);
+    },
+    collapseAllViews() {
+      return this.setAllViews(false);
+    }
+  },
+  bubble: {
+    toggleAllSections(state) {
+      return this.setAllSections(state);
+    },
+    toggleAllViews(state) {
+      return this.setAllViews(state);
+    }
+  },
+  statics: {
+    fromData(comp) {
+      const d = introspectComponent(comp);
+      const sections = [];
+      const add = (label, items, isExpanded = false) => {
+        if (items.length > 0) {
+          sections.push(CompSection.make({ label, items, isExpanded }));
+        }
+      };
+      const names = (list) => list.map((name) => CompName.make({ name }));
+      add("Fields", d.fields.map((f) => CompField.make({
+        name: f.name,
+        typeName: f.type,
+        child: ImInspector.Class.fromData(f.defaultValue)
+      })), true);
+      add("Methods", names(d.methods));
+      add("Input", names(d.input));
+      add("Receive", names(d.receive));
+      add("Bubble", names(d.bubble));
+      add("Response", names(d.response));
+      add("Alter", names(d.alter));
+      add("Statics", names(d.statics));
+      add("Views", d.views.map((v) => CompView.make({ name: v.name, rawView: v.rawView })));
+      return this.make({ compName: d.name, compId: d.id, sections });
+    }
+  },
+  view: html5`<div class="font-mono text-sm leading-tight flex flex-col gap-1">
+    <div class="inline-flex items-center gap-2">
+      <span class="font-semibold" @text=".compName"></span>
+      <span class="text-base-content/40 text-xs" @text="$idText"></span>
+    </div>
+    <x render-each=".sections"></x>
+  </div>`
+});
+function getComponents5() {
+  return [ComponentInspector, CompSection, CompField, CompName, CompView, ...getComponents2()];
+}
+
+// src/components/tutuca/instance-inspector.js
+import { component as component8, html as html8, isRecord } from "tutuca";
+
+// src/components/tutuca/lint-inspector.js
+import { component as component6, html as html6 } from "tutuca";
+var tagDisplay = (tag) => tag ? String(tag).toLowerCase() : "";
+function originSuffix(info) {
+  if (!info)
+    return "";
+  const parts = [];
+  if (info.originAttr) {
+    const branch = info.branch ? `[${info.branch}]` : "";
+    parts.push(`in ${info.originAttr}${branch}`);
+  }
+  if (info.handlerName) {
+    parts.push(`handler '${info.handlerName}'${info.argIndex !== undefined ? ` arg ${info.argIndex}` : ""}`);
+  }
+  const t = tagDisplay(info.tag);
+  if (t && t !== "x")
+    parts.push(`on <${t}>`);
+  return parts.length ? ` (${parts.join(", ")})` : "";
+}
+function tagSuffix(info) {
+  const t = tagDisplay(info?.tag);
+  return t && t !== "x" ? ` on <${t}>` : "";
+}
+function eventSuffix(info) {
+  if (info?.originAttr)
+    return ` in ${info.originAttr}`;
+  if (info?.eventName)
+    return ` in @on.${info.eventName}`;
+  return "";
+}
+function humanizeId(id) {
+  if (!id)
+    return "Lint finding";
+  const s = id.toLowerCase().replace(/_/g, " ");
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function lintMessage(id, info = {}) {
+  switch (id) {
+    case "FIELD_VAL_NOT_DEFINED":
+      return `Field '.${info.name}' is not defined${originSuffix(info)}`;
+    case "FIELD_VAL_IS_METHOD":
+      return `'.${info.name}' reads a field, but '${info.name}' is a method — use '$${info.name}'${originSuffix(info)}`;
+    case "METHOD_VAL_NOT_DEFINED":
+      return `Method '$${info.name}' is not defined${originSuffix(info)}`;
+    case "METHOD_VAL_IS_FIELD":
+      return `'$${info.name}' calls a method, but '${info.name}' is a field — use '.${info.name}'${originSuffix(info)}`;
+    case "INPUT_HANDLER_NOT_IMPLEMENTED":
+      return `Input handler '${info.name}' is not implemented${eventSuffix(info)}`;
+    case "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED":
+      return `Method '$${info.name}' is not implemented${eventSuffix(info)}`;
+    case "INPUT_HANDLER_NOT_REFERENCED":
+      return `Input handler '${info.name}' is defined but never used`;
+    case "ALT_HANDLER_NOT_DEFINED":
+      return `Alter handler '${info.name}' is not defined${originSuffix(info)}`;
+    case "DYN_VAL_NOT_DEFINED":
+      return `Dynamic variable '*${info.name}' is not defined${originSuffix(info)}`;
+    case "UNKNOWN_COMPONENT_NAME":
+      return `Unknown component '${info.name}'${originSuffix(info)}`;
+    case "UNKNOWN_DIRECTIVE":
+      return `Unknown directive '@${info.name}'${tagSuffix(info)}`;
+    case "IF_NO_BRANCH_SET":
+      return `'@if.${info.attr}' has no '@then' or '@else' branch${tagSuffix(info)}`;
+    case "REDUNDANT_TEMPLATE_STRING":
+      return `Redundant template string — '{${info.simpler}}' should be just '${info.simpler}'${originSuffix(info)}`;
+    case "PLACEHOLDERLESS_TEMPLATE_STRING":
+      return `Template string has no dynamic parts — use the literal ${info.literal} instead${originSuffix(info)}`;
+    case "ASYNC_HANDLER":
+      return `Handler '${info.name}' in '${info.channel}' is async — handlers must be synchronous`;
+    case "UNKNOWN_COMPONENT_SPEC_KEY":
+      return `Unknown component spec key '${info.key}' — ignored at runtime`;
+    default:
+      return `${humanizeId(id)}${originSuffix(info)}`;
+  }
+}
+function suggestionText(s) {
+  if (!s)
+    return "";
+  if (s.to != null)
+    return `${s.from ?? ""} → ${s.to}`;
+  return s.text ?? s.kind ?? "";
+}
+var componentView = makeCompositeView({
+  typeClass: "font-semibold",
+  borderClass: "border-base-content/15"
+});
+var LintFinding = component6({
+  name: "LintFinding",
+  fields: { id: "", level: "", message: "", suggestion: "", detail: null },
+  methods: {
+    levelBadgeClass() {
+      const base = "badge badge-sm badge-soft";
+      switch (this.level) {
+        case "error":
+          return `${base} badge-error`;
+        case "warn":
+          return `${base} badge-warning`;
+        default:
+          return `${base} badge-neutral`;
+      }
+    },
+    hasSuggestion() {
+      return this.suggestion !== "";
+    },
+    hasDetail() {
+      return this.detail != null;
+    }
+  },
+  views: {
+    _palette: html6`<span
+      class="badge-soft badge-error badge-warning badge-neutral"
+    ></span>`
+  },
+  view: html6`<div class="flex flex-col gap-1.5 py-1.5 leading-snug">
+    <div class="flex items-baseline gap-2 flex-wrap">
+      <span :class="$levelBadgeClass" @text=".level"></span>
+      <span class="text-sm text-base-content/90" @text=".message"></span>
+    </div>
+    <div
+      @show="$hasSuggestion"
+      class="ml-3 flex items-baseline gap-1.5 text-xs text-base-content/60"
+    >
+      <span>fix</span>
+      <span class="font-mono" @text=".suggestion"></span>
+    </div>
+    <div @show="$hasDetail" class="ml-3"><x render=".detail"></x></div>
+  </div>`
+});
+function buildFinding(f) {
+  const info = f.info ?? {};
+  const ctx = f.context ?? {};
+  return LintFinding.make({
+    id: f.id ?? "",
+    level: f.level ?? "",
+    message: lintMessage(f.id, info),
+    suggestion: suggestionText(f.suggestion),
+    detail: ImInspector.Class.fromData({ id: f.id, info, context: ctx })
+  });
+}
+var LintComponent = component6({
+  name: "LintComponent",
+  fields: { ...compositeFields, componentName: "", errors: 0, warns: 0, hints: 0 },
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return this.componentName;
+    },
+    countText() {
+      const parts = [];
+      if (this.errors)
+        parts.push(`${this.errors} error${this.errors === 1 ? "" : "s"}`);
+      if (this.warns)
+        parts.push(`${this.warns} warning${this.warns === 1 ? "" : "s"}`);
+      if (this.hints)
+        parts.push(`${this.hints} hint${this.hints === 1 ? "" : "s"}`);
+      return parts.length ? parts.join(", ") : "ok";
+    }
+  },
+  alter: compositeAlter,
+  view: componentView
+});
+var LintReport = component6({
+  name: "LintReport",
+  fields: {
+    title: "",
+    path: "",
+    errors: 0,
+    warnings: 0,
+    hints: 0,
+    clean: true,
+    components: []
+  },
+  methods: {
+    errText() {
+      return `${this.errors} error${this.errors === 1 ? "" : "s"}`;
+    },
+    warnText() {
+      return `${this.warnings} warning${this.warnings === 1 ? "" : "s"}`;
+    },
+    hintText() {
+      return `${this.hints} hint${this.hints === 1 ? "" : "s"}`;
+    },
+    hasErrors() {
+      return this.errors > 0;
+    },
+    hasWarnings() {
+      return this.warnings > 0;
+    },
+    hasHints() {
+      return this.hints > 0;
+    }
+  },
+  statics: {
+    fromData(report, { title = "Lint", path = "" } = {}) {
+      const comps = report?.components ?? [];
+      let errors = 0;
+      let warnings = 0;
+      let hints = 0;
+      const built = [];
+      for (const c of comps) {
+        const findings = c.findings ?? [];
+        if (findings.length === 0)
+          continue;
+        const e = findings.filter((f) => f.level === "error").length;
+        const w = findings.filter((f) => f.level === "warn").length;
+        const h = findings.filter((f) => f.level === "hint").length;
+        errors += e;
+        warnings += w;
+        hints += h;
+        built.push(LintComponent.make({
+          componentName: c.componentName,
+          errors: e,
+          warns: w,
+          hints: h,
+          items: findings.map(buildFinding),
+          isExpanded: e > 0
+        }));
+      }
+      return this.make({
+        title,
+        path,
+        errors,
+        warnings,
+        hints,
+        clean: built.length === 0,
+        components: built
+      });
+    }
+  },
+  views: {
+    _palette: html6`<span
+      class="badge-soft badge-error badge-warning badge-neutral badge-success"
+    ></span>`
+  },
+  view: html6`<div class="font-mono text-sm leading-snug flex flex-col gap-3">
+    <div class="flex items-center gap-2 flex-wrap">
+      <span class="font-semibold" @text=".title"></span>
+      <span class="text-base-content/40 text-xs" @text=".path"></span>
+      <span
+        @show="$hasErrors"
+        class="badge badge-sm badge-soft badge-error"
+        @text="$errText"
+      ></span>
+      <span
+        @show="$hasWarnings"
+        class="badge badge-sm badge-soft badge-warning"
+        @text="$warnText"
+      ></span>
+      <span
+        @show="$hasHints"
+        class="badge badge-sm badge-soft badge-neutral"
+        @text="$hintText"
+      ></span>
+      <span
+        @show=".clean"
+        class="badge badge-sm badge-soft badge-success"
+        >✓ clean</span
+      >
+    </div>
+    <x render-each=".components"></x>
+  </div>`
+});
+function getComponents6() {
+  return [LintReport, LintComponent, LintFinding, ...getComponents2()];
+}
+
+// src/components/tutuca/test-inspector.js
+import { component as component7, html as html7 } from "tutuca";
+function collectTests(getTests) {
+  const root = { children: [] };
+  const stack = [root];
+  const describe = (head, optsOrFn, maybeFn) => {
+    const fn = typeof maybeFn === "function" ? maybeFn : optsOrFn;
+    const title = typeof head === "string" ? head : head?.name ?? String(head);
+    const node = { title, children: [] };
+    stack[stack.length - 1].children.push(node);
+    stack.push(node);
+    try {
+      fn();
+    } finally {
+      stack.pop();
+    }
+  };
+  const test = (title) => {
+    stack[stack.length - 1].children.push({ title });
+  };
+  const noop = () => {};
+  getTests({ describe, test, expect: noop, drive: async () => null });
+  return root.children;
+}
+var suiteView = makeCompositeView({
+  typeClass: "font-semibold",
+  borderClass: "border-base-content/15",
+  toggleHandler: "toggle isCtrl"
+});
+var TestCase = component7({
+  name: "TestCase",
+  fields: { title: "", status: "", durationMs: 0, message: "", detail: null },
+  methods: {
+    mark() {
+      switch (this.status) {
+        case "pass":
+          return "✓";
+        case "fail":
+          return "✗";
+        case "skip":
+          return "○";
+        default:
+          return "•";
+      }
+    },
+    markClass() {
+      const base = "font-mono text-sm";
+      switch (this.status) {
+        case "pass":
+          return `${base} text-success`;
+        case "fail":
+          return `${base} text-error`;
+        default:
+          return `${base} text-base-content/40`;
+      }
+    },
+    durText() {
+      return this.status && this.status !== "skip" ? `(${Math.round(this.durationMs)}ms)` : "";
+    },
+    hasMessage() {
+      return this.message !== "";
+    },
+    hasDetail() {
+      return this.detail != null;
+    }
+  },
+  views: {
+    _palette: html7`<span class="text-success text-error text-base-content/40"></span>`
+  },
+  view: html7`<div class="flex flex-col gap-0.5 leading-tight">
+    <div class="flex items-center gap-2">
+      <span :class="$markClass" @text="$mark"></span>
+      <span class="font-mono text-sm" @text=".title"></span>
+      <span class="text-base-content/40 text-xs" @text="$durText"></span>
+    </div>
+    <div @show="$hasMessage" class="ml-5 text-error text-xs" @text=".message"></div>
+    <div @show="$hasDetail" class="ml-5"><x render=".detail"></x></div>
+  </div>`
+});
+var TestSuite = component7({
+  name: "TestSuite",
+  fields: { ...compositeFields, title: "", summary: "" },
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return this.title;
+    },
+    countText() {
+      return this.summary || `(${this.items.size})`;
+    }
+  },
+  input: {
+    toggle(isCtrl, ctx) {
+      if (isCtrl) {
+        ctx.bubble("toggleAll", [!this.isExpanded]);
+        return this;
+      }
+      return this.toggleIsExpanded();
+    }
+  },
+  alter: compositeAlter,
+  view: suiteView
+});
+function setSuiteTreeExpanded(node, state) {
+  if (typeof node.setIsExpanded !== "function")
+    return node;
+  return node.setIsExpanded(state).setItems(node.items.map((c) => setSuiteTreeExpanded(c, state)));
+}
+function buildDefNode(node) {
+  if (Array.isArray(node.children)) {
+    return TestSuite.make({
+      title: node.title,
+      items: node.children.map(buildDefNode)
+    });
+  }
+  return TestCase.make({ title: node.title });
+}
+function buildResultNode(node) {
+  if (Array.isArray(node.children)) {
+    const built = node.children.map(buildResultNode);
+    const pass = built.reduce((n, b) => n + b.pass, 0);
+    const fail = built.reduce((n, b) => n + b.fail, 0);
+    const skip = built.reduce((n, b) => n + b.skip, 0);
+    const summary = `✓${pass}${fail ? ` ✗${fail}` : ""}${skip ? ` ○${skip}` : ""}`;
+    const comp2 = TestSuite.make({
+      title: node.title,
+      summary,
+      items: built.map((b) => b.comp),
+      isExpanded: fail > 0
+    });
+    return { comp: comp2, pass, fail, skip };
+  }
+  const status = node.status ?? "";
+  const err = node.error ?? null;
+  const hasDiff = err != null && (("expected" in err) || ("actual" in err));
+  const comp = TestCase.make({
+    title: node.title,
+    status,
+    durationMs: node.durationMs ?? 0,
+    message: err?.message ?? "",
+    detail: hasDiff ? ImInspector.Class.fromData({ expected: err.expected, actual: err.actual }) : null
+  });
+  return {
+    comp,
+    pass: status === "pass" ? 1 : 0,
+    fail: status === "fail" ? 1 : 0,
+    skip: status === "skip" ? 1 : 0
+  };
+}
+var TestReport = component7({
+  name: "TestReport",
+  fields: {
+    title: "",
+    path: "",
+    pass: 0,
+    fail: 0,
+    skip: 0,
+    hasCounts: false,
+    suites: []
+  },
+  methods: {
+    passText() {
+      return `✓ ${this.pass}`;
+    },
+    failText() {
+      return `✗ ${this.fail}`;
+    },
+    skipText() {
+      return `○ ${this.skip}`;
+    },
+    hasFailures() {
+      return this.hasCounts && this.fail > 0;
+    },
+    hasSkips() {
+      return this.hasCounts && this.skip > 0;
+    },
+    setAllSuites(state) {
+      return this.setSuites(this.suites.map((s) => setSuiteTreeExpanded(s, state)));
+    }
+  },
+  bubble: {
+    toggleAll(state) {
+      return this.setAllSuites(state);
+    }
+  },
+  statics: {
+    fromTests(source, { title = "Tests", path = "" } = {}) {
+      const suites = Array.isArray(source) ? source : source?.suites ?? [];
+      return this.make({
+        title,
+        path,
+        hasCounts: false,
+        suites: suites.map(buildDefNode)
+      });
+    },
+    fromResults(report) {
+      const mod = report?.modules ? report.modules[0] : report;
+      const { path = "", suites = [], counts = {} } = mod ?? {};
+      return this.make({
+        title: "Test run",
+        path,
+        pass: counts.pass ?? 0,
+        fail: counts.fail ?? 0,
+        skip: counts.skip ?? 0,
+        hasCounts: true,
+        suites: suites.map((s) => buildResultNode(s).comp)
+      });
+    }
+  },
+  view: html7`<div class="font-mono text-sm leading-tight flex flex-col gap-1">
+    <div class="flex items-center gap-2 flex-wrap">
+      <span class="font-semibold" @text=".title"></span>
+      <span class="text-base-content/40 text-xs" @text=".path"></span>
+      <span
+        @show=".hasCounts"
+        class="badge badge-sm badge-soft badge-success"
+        @text="$passText"
+      ></span>
+      <span
+        @show="$hasFailures"
+        class="badge badge-sm badge-soft badge-error"
+        @text="$failText"
+      ></span>
+      <span
+        @show="$hasSkips"
+        class="badge badge-sm badge-soft badge-neutral"
+        @text="$skipText"
+      ></span>
+    </div>
+    <x render-each=".suites"></x>
+  </div>`
+});
+function getComponents7() {
+  return [TestReport, TestSuite, TestCase, ...getComponents2()];
+}
+
+// src/components/tutuca/instance-inspector.js
+var isComponentInstance = (v) => isRecord(v) && typeof v?.constructor?.getMetaClass === "function";
+var fieldsView = makeCompositeView({
+  typeClass: "font-semibold",
+  borderClass: "border-base-content/15"
+});
+var InstanceFields = component8({
+  name: "InstanceFields",
+  fields: { ...compositeFields, typeName: "" },
+  methods: {
+    ...compositeMethods,
+    typeText() {
+      return this.typeName;
+    },
+    countText() {
+      return `{${this.items.size}}`;
+    }
+  },
+  alter: compositeAlter,
+  statics: {
+    fromData(instance, comp) {
+      const d = introspectComponent(comp);
+      const items = d.fields.map((f) => ImEntry.make({
+        key: f.name,
+        child: ImInspector.Class.fromData(instance.get(f.name))
+      }));
+      return this.make({ typeName: d.name, items, isExpanded: true });
+    }
+  },
+  view: fieldsView
+});
+var InstanceInspector = component8({
+  name: "InstanceInspector",
+  fields: { value: null },
+  methods: {
+    toggleIsExpanded() {
+      return typeof this.value?.toggleIsExpanded === "function" ? this.setValue(this.value.toggleIsExpanded()) : this;
+    }
+  },
+  statics: {
+    fromData(instance, comp) {
+      const value = comp && isComponentInstance(instance) ? InstanceFields.Class.fromData(instance, comp) : ImInspector.Class.fromData(instance);
+      return this.make({ value });
+    }
+  },
+  view: html8`<span class="contents"><x render=".value"></x></span>`
+});
+function asTestView(tests) {
+  if (tests == null)
+    return null;
+  return isComponentInstance(tests) ? tests : TestReport.Class.fromResults(tests);
+}
+function asLintView(lint) {
+  if (lint == null)
+    return null;
+  return isComponentInstance(lint) ? lint : LintReport.Class.fromData(lint);
+}
+var InstanceExplorer = component8({
+  name: "InstanceExplorer",
+  fields: {
+    activeTab: "instance",
+    instanceView: null,
+    componentView: null,
+    testView: null,
+    lintView: null,
+    hasComponent: false,
+    hasTests: false,
+    hasLint: false
+  },
+  statics: {
+    fromData(instance, comp, { tests = null, lint = null } = {}) {
+      const testView = asTestView(tests);
+      const lintView = asLintView(lint);
+      return this.make({
+        instanceView: InstanceInspector.Class.fromData(instance, comp),
+        componentView: comp ? ComponentInspector.Class.fromData(comp) : null,
+        testView,
+        lintView,
+        hasComponent: !!comp,
+        hasTests: !!testView,
+        hasLint: !!lintView
+      });
+    }
+  },
+  view: html8`<div class="font-mono text-sm leading-snug flex flex-col gap-3">
+    <div role="tablist" class="tabs">
+      <a
+        role="tab"
+        @if.class="equals? .activeTab 'instance'"
+        @then="'tab tab-active'"
+        @else="'tab'"
+        @on.click="$setActiveTab 'instance'"
+      >
+        Instance
+      </a>
+      <a
+        role="tab"
+        @show=".hasComponent"
+        @if.class="equals? .activeTab 'component'"
+        @then="'tab tab-active'"
+        @else="'tab'"
+        @on.click="$setActiveTab 'component'"
+      >
+        Component
+      </a>
+      <a
+        role="tab"
+        @show=".hasTests"
+        @if.class="equals? .activeTab 'tests'"
+        @then="'tab tab-active'"
+        @else="'tab'"
+        @on.click="$setActiveTab 'tests'"
+      >
+        Tests
+      </a>
+      <a
+        role="tab"
+        @show=".hasLint"
+        @if.class="equals? .activeTab 'lint'"
+        @then="'tab tab-active'"
+        @else="'tab'"
+        @on.click="$setActiveTab 'lint'"
+      >
+        Lint
+      </a>
+    </div>
+    <div @show="equals? .activeTab 'instance'">
+      <x render=".instanceView"></x>
+    </div>
+    <div @show="equals? .activeTab 'component'">
+      <div @show=".hasComponent"><x render=".componentView"></x></div>
+      <div @hide=".hasComponent" class="text-base-content/50 text-xs">
+        Pass the Component descriptor to inspect its definition.
+      </div>
+    </div>
+    <div @show="equals? .activeTab 'tests'">
+      <x render=".testView"></x>
+    </div>
+    <div @show="equals? .activeTab 'lint'">
+      <x render=".lintView"></x>
+    </div>
+  </div>`
+});
+function getComponents8() {
+  const all = [
+    InstanceExplorer,
+    InstanceInspector,
+    InstanceFields,
+    ...getComponents5(),
+    ...getComponents7(),
+    ...getComponents6()
+  ];
+  const seen = new Set;
+  return all.filter((c) => {
+    if (seen.has(c.name))
+      return false;
+    seen.add(c.name);
+    return true;
+  });
+}
+
+// src/components/build-views.js
+async function buildInspectorViews(value, scope, { getTests = null, components = [], dev = null, name } = {}) {
+  const comp = isComponentInstance(value) ? scope.getCompFor(value) : null;
+  const out = {
+    instanceView: InstanceInspector.Class.fromData(value, scope.getCompFor(value)),
+    componentView: null,
+    lintView: null,
+    testView: null,
+    hasInspect: true,
+    hasComponent: false,
+    hasLint: false,
+    hasTest: false
+  };
+  if (comp) {
+    out.componentView = ComponentInspector.Class.fromData(comp);
+    out.hasComponent = true;
+    if (dev) {
+      const findings = dev.shadowCheckComponent(comp);
+      out.lintView = LintReport.Class.fromData({
+        components: [{ componentName: comp.name, findings }]
+      });
+      out.hasLint = true;
+      if (getTests) {
+        const report = await dev.runTests({
+          getTests,
+          components,
+          expect: dev.expect,
+          name: name === undefined ? comp.name : name
+        });
+        out.testView = TestReport.Class.fromResults(report);
+        out.hasTest = true;
+      }
+    }
+  }
+  return out;
+}
+
+// src/components/index.js
+function getComponents9() {
+  const all = [
+    ...getComponents5(),
+    ...getComponents8(),
+    ...getComponents6(),
+    ...getComponents7(),
+    ...getComponents3(),
+    ...getComponents4(),
+    ...getComponents2(),
+    ...getComponents()
+  ];
+  const seen = new Set;
+  return all.filter((c) => {
+    if (seen.has(c.name))
+      return false;
+    seen.add(c.name);
+    return true;
+  });
+}
+export {
+  makeCompositeView,
+  lintMessage,
+  isComponentInstance,
+  introspectComponent,
+  getComponents9 as getComponents,
+  fmtMapKey,
+  fmtAnyKey,
+  compositeView,
+  compositeMethods,
+  compositeFields,
+  compositeAlter,
+  collectTests,
+  classifySchema,
+  classifyJson,
+  classifyJsExtra,
+  classifyImmutable,
+  classifyData,
+  chain,
+  buildInspectorViews,
+  TestSuite,
+  TestReport,
+  TestCase,
+  SchemaViewer,
+  SchemaScalar,
+  SchemaRef,
+  SchemaProperty,
+  SchemaObject,
+  SchemaNot,
+  SchemaEnum,
+  SchemaConst,
+  SchemaConditional,
+  SchemaCombinator,
+  SchemaBranch,
+  SchemaBoolean,
+  SchemaArray,
+  LintReport,
+  LintFinding,
+  LintComponent,
+  JsonViewer,
+  JsonString,
+  JsonProperty,
+  JsonObject,
+  JsonNumber,
+  JsonNull,
+  JsonBoolean,
+  JsonArray,
+  JsUndefined,
+  JsSymbol,
+  JsSetItem,
+  JsSet,
+  JsRegExp,
+  JsMap,
+  JsFunction,
+  JsError,
+  JsDate,
+  JsClassInstance,
+  JsBigInt,
+  InstanceInspector,
+  InstanceFields,
+  InstanceExplorer,
+  ImStack,
+  ImSet,
+  ImRecord,
+  ImRange,
+  ImOSet,
+  ImOMap,
+  ImMap,
+  ImList,
+  ImInspector,
+  ImEntry,
+  DataInspector,
+  ComponentInspector,
+  CompView,
+  CompSection,
+  CompName,
+  CompField
+};