@noya-app/noya-multiplayer-react 0.1.49 → 0.1.51

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,6 +31,886 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/tree-visit/lib/access.js
+var require_access = __commonJS({
+  "../../node_modules/tree-visit/lib/access.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.accessPath = exports2.access = void 0;
+    function access(node, indexPath, options) {
+      if (options.includeTraversalContext) {
+        const accessed = accessPath(node, indexPath, options);
+        return accessed[accessed.length - 1];
+      }
+      let path = indexPath.slice();
+      while (path.length > 0) {
+        let index = path.shift();
+        node = options.getChildren(node, path)[index];
+      }
+      return node;
+    }
+    exports2.access = access;
+    function accessPath(node, indexPath, options) {
+      let path = indexPath.slice();
+      let result = [node];
+      while (path.length > 0) {
+        let index = path.shift();
+        const context = options.includeTraversalContext ? {
+          getRoot: () => result[0],
+          getParent: () => result[result.length - 2],
+          getAncestors: () => result.slice(0, -1)
+        } : void 0;
+        node = options.getChildren(node, path, context)[index];
+        result.push(node);
+      }
+      return result;
+    }
+    exports2.accessPath = accessPath;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/sort.js
+var require_sort = __commonJS({
+  "../../node_modules/tree-visit/lib/sort.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sortIndexPaths = exports2.compareIndexPaths = void 0;
+    function compareIndexPaths(a, b) {
+      for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        if (a[i] < b[i])
+          return -1;
+        if (a[i] > b[i])
+          return 1;
+      }
+      return a.length - b.length;
+    }
+    exports2.compareIndexPaths = compareIndexPaths;
+    function sortIndexPaths(indexPaths) {
+      return indexPaths.sort(compareIndexPaths);
+    }
+    exports2.sortIndexPaths = sortIndexPaths;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/ancestors.js
+var require_ancestors = __commonJS({
+  "../../node_modules/tree-visit/lib/ancestors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ancestorIndexPaths = void 0;
+    var sort_1 = require_sort();
+    function ancestorIndexPaths(indexPaths) {
+      const paths = /* @__PURE__ */ new Map();
+      const sortedIndexPaths = (0, sort_1.sortIndexPaths)(indexPaths);
+      for (const indexPath of sortedIndexPaths) {
+        const foundParent = indexPath.some((_, index) => {
+          const parentKey = indexPath.slice(0, index).join();
+          return paths.has(parentKey);
+        });
+        if (foundParent)
+          continue;
+        paths.set(indexPath.join(), indexPath);
+      }
+      return Array.from(paths.values());
+    }
+    exports2.ancestorIndexPaths = ancestorIndexPaths;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/diagram/boxDiagram.js
+var require_boxDiagram = __commonJS({
+  "../../node_modules/tree-visit/lib/diagram/boxDiagram.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.boxDiagram = void 0;
+    var BoxDrawing;
+    (function(BoxDrawing2) {
+      BoxDrawing2["TopLeft"] = "\u250C";
+      BoxDrawing2["TopRight"] = "\u2510";
+      BoxDrawing2["BottomLeft"] = "\u2514";
+      BoxDrawing2["BottomRight"] = "\u2518";
+      BoxDrawing2["Horizontal"] = "\u2500";
+      BoxDrawing2["Vertical"] = "\u2502";
+      BoxDrawing2["BottomConnectorDown"] = "\u252C";
+      BoxDrawing2["BottomConnectorUp"] = "\u2534";
+      BoxDrawing2["TopConnectorUp"] = "\u2534";
+    })(BoxDrawing || (BoxDrawing = {}));
+    function wrapLabelInBox(label) {
+      const lines = label.split("\n");
+      const length = Math.max(...lines.map((line) => line.length));
+      const horizontalMargin = 1;
+      const width = length + horizontalMargin * 2 + 2;
+      const height = 2 + lines.length;
+      const diagram = [
+        [
+          BoxDrawing.TopLeft,
+          BoxDrawing.Horizontal.repeat(length + horizontalMargin * 2),
+          BoxDrawing.TopRight
+        ],
+        ...lines.map((line) => [
+          BoxDrawing.Vertical,
+          " ".repeat(horizontalMargin),
+          line + (line.length < length ? " ".repeat(length - line.length) : ""),
+          " ".repeat(horizontalMargin),
+          BoxDrawing.Vertical
+        ]),
+        [
+          BoxDrawing.BottomLeft,
+          BoxDrawing.Horizontal.repeat(length + horizontalMargin * 2),
+          BoxDrawing.BottomRight
+        ]
+      ];
+      return {
+        width,
+        height,
+        contents: diagram.map((parts) => parts.join(""))
+      };
+    }
+    function mergeBoxesHorizontal(boxes) {
+      const horizontalMargin = 1;
+      if (boxes.length === 0) {
+        throw new Error("Can't merge empty array of boxes");
+      }
+      return boxes.slice(1).reduce((result, box) => {
+        const height = Math.max(result.height, box.height);
+        const width = result.width + horizontalMargin + box.width;
+        const contents = [];
+        for (let i = 0; i < height; i++) {
+          contents.push((result.contents[i] || " ".repeat(result.width)) + " ".repeat(horizontalMargin) + (box.contents[i] || " ".repeat(box.width)));
+        }
+        return { height, width, contents: centerBlock(contents, width) };
+      }, boxes[0]);
+    }
+    function mergeBoxesVertical(boxes) {
+      const verticalMargin = 1;
+      if (boxes.length === 0) {
+        throw new Error("Can't merge empty array of boxes");
+      }
+      const width = Math.max(...boxes.map((box) => box.width));
+      return boxes.slice(1).reduce((result, box) => {
+        const height = result.height + verticalMargin + box.height;
+        const contents = [];
+        for (let i = 0; i < height; i++) {
+          if (i < result.height) {
+            contents.push(result.contents[i]);
+          } else if (i === result.height) {
+            contents.push(" ".repeat(width));
+          } else {
+            contents.push(box.contents[i - result.height - 1]);
+          }
+        }
+        return { height, width, contents: centerBlock(contents, width) };
+      }, boxes[0]);
+    }
+    function nodeDiagram(node, indexPath, options) {
+      const label = options.getLabel(node, indexPath);
+      const box = wrapLabelInBox(label);
+      const children = options.getChildren(node, indexPath);
+      if (children.length === 0)
+        return box;
+      const childBoxes = children.map((child, index) => {
+        const childBox = nodeDiagram(child, [...indexPath, index], options);
+        childBox.contents[0] = insertSubstring(childBox.contents[0], centerIndex(childBox.contents[0].length), BoxDrawing.TopConnectorUp);
+        return childBox;
+      });
+      const result = mergeBoxesVertical([box, mergeBoxesHorizontal(childBoxes)]);
+      const contents = result.contents;
+      const mid = centerIndex(result.width);
+      contents[box.height - 1] = insertSubstring(contents[box.height - 1], mid, BoxDrawing.BottomConnectorDown);
+      let min = contents[box.height + 1].indexOf(BoxDrawing.TopConnectorUp);
+      let max = contents[box.height + 1].lastIndexOf(BoxDrawing.TopConnectorUp);
+      for (let i = min; i <= max; i++) {
+        let character;
+        if (i === mid) {
+          character = childBoxes.length > 1 ? BoxDrawing.BottomConnectorUp : BoxDrawing.Vertical;
+        } else if (i === min) {
+          character = BoxDrawing.TopLeft;
+        } else if (i === max) {
+          character = BoxDrawing.TopRight;
+        } else {
+          character = BoxDrawing.Horizontal;
+        }
+        result.contents[box.height] = insertSubstring(result.contents[box.height], i, character);
+      }
+      return result;
+    }
+    function boxDiagram(node, options) {
+      return nodeDiagram(node, [], options).contents.join("\n");
+    }
+    exports2.boxDiagram = boxDiagram;
+    function centerIndex(width) {
+      return Math.floor(width / 2);
+    }
+    function centerLine(line, width) {
+      const remainder = width - line.length;
+      if (remainder <= 0)
+        return line;
+      const prefixLength = centerIndex(remainder);
+      const suffixLength = centerIndex(remainder);
+      const result = " ".repeat(prefixLength) + line + " ".repeat(suffixLength);
+      return prefixLength + suffixLength + result.length < width ? result + " " : result;
+    }
+    function centerBlock(lines, width) {
+      return lines.map((line) => centerLine(line, width));
+    }
+    function insertSubstring(string, index, substring) {
+      if (index > string.length - 1)
+        return string;
+      return string.substring(0, index) + substring + string.substring(index + 1);
+    }
+  }
+});
+
+// ../../node_modules/tree-visit/lib/diagram/directoryDiagram.js
+var require_directoryDiagram = __commonJS({
+  "../../node_modules/tree-visit/lib/diagram/directoryDiagram.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.prefixBlock = exports2.isMultiline = exports2.directoryDiagram = void 0;
+    var LinePrefix;
+    (function(LinePrefix2) {
+      LinePrefix2["Child"] = "\u251C\u2500\u2500 ";
+      LinePrefix2["LastChild"] = "\u2514\u2500\u2500 ";
+      LinePrefix2["NestedChild"] = "\u2502   ";
+      LinePrefix2["LastNestedChild"] = "    ";
+    })(LinePrefix || (LinePrefix = {}));
+    function nodeDiagram(node, indexPath, options) {
+      const label = options.getLabel(node, indexPath);
+      const depth = indexPath.length;
+      let rootLine = { label, depth, prefix: "", multilinePrefix: "" };
+      const children = options.getChildren(node, indexPath);
+      if (children.length === 0)
+        return [rootLine];
+      if (options.flattenSingleChildNodes && children.length === 1 && !isMultiline(label)) {
+        const [line] = nodeDiagram(children[0], [...indexPath, 0], options);
+        const hideRoot = indexPath.length === 0 && label === "";
+        rootLine.label = hideRoot ? `/ ${line.label}` : `${rootLine.label} / ${line.label}`;
+        return [rootLine];
+      }
+      const nestedLines = children.flatMap((file, index, array) => {
+        const childIsLast = index === array.length - 1;
+        const childLines = nodeDiagram(file, [...indexPath, index], options);
+        const childPrefix = childIsLast ? LinePrefix.LastChild : LinePrefix.Child;
+        const childMultilinePrefix = childIsLast ? LinePrefix.LastNestedChild : LinePrefix.NestedChild;
+        childLines.forEach((line) => {
+          if (line.depth === depth + 1) {
+            line.prefix = childPrefix + line.prefix;
+            line.multilinePrefix = childMultilinePrefix + line.multilinePrefix;
+          } else if (childIsLast) {
+            line.prefix = LinePrefix.LastNestedChild + line.prefix;
+            line.multilinePrefix = LinePrefix.LastNestedChild + line.multilinePrefix;
+          } else {
+            line.prefix = LinePrefix.NestedChild + line.prefix;
+            line.multilinePrefix = LinePrefix.NestedChild + line.multilinePrefix;
+          }
+        });
+        return childLines;
+      });
+      return [rootLine, ...nestedLines];
+    }
+    function directoryDiagram(node, options) {
+      const lines = nodeDiagram(node, [], options);
+      const strings = lines.map((line) => prefixBlock(line.label, line.prefix, line.multilinePrefix));
+      return strings.join("\n");
+    }
+    exports2.directoryDiagram = directoryDiagram;
+    function isMultiline(line) {
+      return line.includes("\n");
+    }
+    exports2.isMultiline = isMultiline;
+    function prefixBlock(block, prefix, multilinePrefix) {
+      if (!isMultiline(block))
+        return prefix + block;
+      return block.split("\n").map((line, index) => (index === 0 ? prefix : multilinePrefix) + line).join("\n");
+    }
+    exports2.prefixBlock = prefixBlock;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/diagram.js
+var require_diagram = __commonJS({
+  "../../node_modules/tree-visit/lib/diagram.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.diagram = void 0;
+    var boxDiagram_1 = require_boxDiagram();
+    var directoryDiagram_1 = require_directoryDiagram();
+    function diagram(node, options) {
+      if (options.type === "box") {
+        return (0, boxDiagram_1.boxDiagram)(node, options);
+      }
+      return (0, directoryDiagram_1.directoryDiagram)(node, options);
+    }
+    exports2.diagram = diagram;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/visit.js
+var require_visit = __commonJS({
+  "../../node_modules/tree-visit/lib/visit.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.visit = exports2.STOP = exports2.SKIP = void 0;
+    exports2.SKIP = "skip";
+    exports2.STOP = "stop";
+    function visit(node, options) {
+      const { onEnter, onLeave, getChildren, onDetectCycle, getIdentifier } = options;
+      let indexPath = [];
+      let stack = [{ node }];
+      const visited = onDetectCycle ? /* @__PURE__ */ new Set() : void 0;
+      const context = options.includeTraversalContext ? {
+        getRoot() {
+          return node;
+        },
+        getParent() {
+          var _a;
+          return (_a = stack[stack.length - 2]) === null || _a === void 0 ? void 0 : _a.node;
+        },
+        getAncestors() {
+          return stack.slice(0, -1).map((wrapper) => wrapper.node);
+        }
+      } : void 0;
+      const getIndexPath = options.reuseIndexPath ? () => indexPath : () => indexPath.slice();
+      while (stack.length > 0) {
+        let wrapper = stack[stack.length - 1];
+        if (wrapper.state === void 0) {
+          if (visited) {
+            const id = getIdentifier ? getIdentifier(wrapper.node) : wrapper.node;
+            if (visited.has(id)) {
+              const action = typeof onDetectCycle === "function" ? onDetectCycle(wrapper.node, getIndexPath(), context) : onDetectCycle;
+              if (action === "error") {
+                throw new Error("Cycle detected in tree");
+              } else {
+                wrapper.state = -1;
+                continue;
+              }
+            }
+            visited.add(id);
+          }
+          const enterResult = onEnter === null || onEnter === void 0 ? void 0 : onEnter(wrapper.node, getIndexPath());
+          if (enterResult === exports2.STOP)
+            return;
+          wrapper.state = enterResult === exports2.SKIP ? -1 : 0;
+        }
+        const children = wrapper.children || getChildren(wrapper.node, getIndexPath(), context);
+        if (!wrapper.children) {
+          wrapper.children = children;
+        }
+        if (wrapper.state !== -1) {
+          if (wrapper.state < children.length) {
+            let currentIndex = wrapper.state;
+            indexPath.push(currentIndex);
+            stack.push({ node: children[currentIndex] });
+            wrapper.state = currentIndex + 1;
+            continue;
+          }
+          const leaveResult = onLeave === null || onLeave === void 0 ? void 0 : onLeave(wrapper.node, getIndexPath());
+          if (leaveResult === exports2.STOP)
+            return;
+        }
+        if (visited) {
+          const id = getIdentifier ? getIdentifier(wrapper.node) : wrapper.node;
+          visited.delete(id);
+        }
+        indexPath.pop();
+        stack.pop();
+      }
+    }
+    exports2.visit = visit;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/find.js
+var require_find = __commonJS({
+  "../../node_modules/tree-visit/lib/find.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.findAllIndexPaths = exports2.findIndexPath = exports2.findAll = exports2.find = void 0;
+    var visit_1 = require_visit();
+    function find(node, options) {
+      let found;
+      (0, visit_1.visit)(node, Object.assign(Object.assign({}, options), { onEnter: (child, indexPath) => {
+        if (options.predicate(child, indexPath)) {
+          found = child;
+          return visit_1.STOP;
+        }
+      } }));
+      return found;
+    }
+    exports2.find = find;
+    function findAll(node, options) {
+      let found = [];
+      (0, visit_1.visit)(node, {
+        onEnter: (child, indexPath) => {
+          if (options.predicate(child, indexPath)) {
+            found.push(child);
+          }
+        },
+        getChildren: options.getChildren
+      });
+      return found;
+    }
+    exports2.findAll = findAll;
+    function findIndexPath(node, options) {
+      let found;
+      (0, visit_1.visit)(node, {
+        onEnter: (child, indexPath) => {
+          if (options.predicate(child, indexPath)) {
+            found = [...indexPath];
+            return visit_1.STOP;
+          }
+        },
+        getChildren: options.getChildren
+      });
+      return found;
+    }
+    exports2.findIndexPath = findIndexPath;
+    function findAllIndexPaths(node, options) {
+      let found = [];
+      (0, visit_1.visit)(node, {
+        onEnter: (child, indexPath) => {
+          if (options.predicate(child, indexPath)) {
+            found.push([...indexPath]);
+          }
+        },
+        getChildren: options.getChildren
+      });
+      return found;
+    }
+    exports2.findAllIndexPaths = findAllIndexPaths;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/reduce.js
+var require_reduce = __commonJS({
+  "../../node_modules/tree-visit/lib/reduce.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.reduce = void 0;
+    var visit_1 = require_visit();
+    function reduce(node, options) {
+      let result = options.initialResult;
+      (0, visit_1.visit)(node, Object.assign(Object.assign({}, options), { onEnter: (child, indexPath) => {
+        result = options.nextResult(result, child, indexPath);
+      } }));
+      return result;
+    }
+    exports2.reduce = reduce;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/flat.js
+var require_flat = __commonJS({
+  "../../node_modules/tree-visit/lib/flat.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.flat = void 0;
+    var reduce_1 = require_reduce();
+    function flat(node, options) {
+      return (0, reduce_1.reduce)(node, Object.assign(Object.assign({}, options), { initialResult: [], nextResult: (result, child) => {
+        result.push(child);
+        return result;
+      } }));
+    }
+    exports2.flat = flat;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/flatMap.js
+var require_flatMap = __commonJS({
+  "../../node_modules/tree-visit/lib/flatMap.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.flatMap = void 0;
+    var reduce_1 = require_reduce();
+    function flatMap(node, options) {
+      return (0, reduce_1.reduce)(node, Object.assign(Object.assign({}, options), { initialResult: [], nextResult: (result, child, indexPath) => {
+        result.push(...options.transform(child, indexPath));
+        return result;
+      } }));
+    }
+    exports2.flatMap = flatMap;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/map.js
+var require_map = __commonJS({
+  "../../node_modules/tree-visit/lib/map.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.map = void 0;
+    var visit_1 = require_visit();
+    function map3(node, options) {
+      const childrenMap = {};
+      (0, visit_1.visit)(node, Object.assign(Object.assign({}, options), { onLeave: (child, indexPath) => {
+        var _a, _b;
+        const keyIndexPath = [0, ...indexPath];
+        const key = keyIndexPath.join();
+        const transformed = options.transform(child, (_a = childrenMap[key]) !== null && _a !== void 0 ? _a : [], indexPath);
+        const parentKey = keyIndexPath.slice(0, -1).join();
+        const parentChildren = (_b = childrenMap[parentKey]) !== null && _b !== void 0 ? _b : [];
+        parentChildren.push(transformed);
+        childrenMap[parentKey] = parentChildren;
+      } }));
+      return childrenMap[""][0];
+    }
+    exports2.map = map3;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/operation.js
+var require_operation = __commonJS({
+  "../../node_modules/tree-visit/lib/operation.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.splice = exports2.applyOperations = exports2.getReplaceOperations = exports2.getRemovalOperations = exports2.getInsertionOperations = exports2.replaceOperation = exports2.removeOperation = exports2.insertOperation = void 0;
+    var ancestors_1 = require_ancestors();
+    var map_1 = require_map();
+    function insertOperation(index, nodes) {
+      return {
+        type: "insert",
+        index,
+        nodes
+      };
+    }
+    exports2.insertOperation = insertOperation;
+    function removeOperation(indexes) {
+      return {
+        type: "remove",
+        indexes
+      };
+    }
+    exports2.removeOperation = removeOperation;
+    function replaceOperation() {
+      return {
+        type: "replace"
+      };
+    }
+    exports2.replaceOperation = replaceOperation;
+    function splitIndexPath(indexPath) {
+      return [indexPath.slice(0, -1), indexPath[indexPath.length - 1]];
+    }
+    function getInsertionOperations(indexPath, nodes, operations = /* @__PURE__ */ new Map()) {
+      var _a;
+      const [parentIndexPath, index] = splitIndexPath(indexPath);
+      for (let i = parentIndexPath.length - 1; i >= 0; i--) {
+        const parentKey = parentIndexPath.slice(0, i).join();
+        switch ((_a = operations.get(parentKey)) === null || _a === void 0 ? void 0 : _a.type) {
+          case "remove":
+            continue;
+        }
+        operations.set(parentKey, replaceOperation());
+      }
+      const operation = operations.get(parentIndexPath.join());
+      switch (operation === null || operation === void 0 ? void 0 : operation.type) {
+        case "remove":
+          operations.set(parentIndexPath.join(), {
+            type: "removeThenInsert",
+            removeIndexes: operation.indexes,
+            insertIndex: index,
+            insertNodes: nodes
+          });
+          break;
+        default:
+          operations.set(parentIndexPath.join(), insertOperation(index, nodes));
+      }
+      return operations;
+    }
+    exports2.getInsertionOperations = getInsertionOperations;
+    function getRemovalOperations(indexPaths) {
+      var _a, _b;
+      const _ancestorIndexPaths = (0, ancestors_1.ancestorIndexPaths)(indexPaths);
+      const indexesToRemove = /* @__PURE__ */ new Map();
+      for (const indexPath of _ancestorIndexPaths) {
+        const parentKey = indexPath.slice(0, -1).join();
+        const value = (_a = indexesToRemove.get(parentKey)) !== null && _a !== void 0 ? _a : [];
+        value.push(indexPath[indexPath.length - 1]);
+        indexesToRemove.set(parentKey, value);
+      }
+      const operations = /* @__PURE__ */ new Map();
+      for (const indexPath of _ancestorIndexPaths) {
+        for (let i = indexPath.length - 1; i >= 0; i--) {
+          const parentKey = indexPath.slice(0, i).join();
+          operations.set(parentKey, replaceOperation());
+        }
+      }
+      for (const indexPath of _ancestorIndexPaths) {
+        const parentKey = indexPath.slice(0, -1).join();
+        operations.set(parentKey, removeOperation((_b = indexesToRemove.get(parentKey)) !== null && _b !== void 0 ? _b : []));
+      }
+      return operations;
+    }
+    exports2.getRemovalOperations = getRemovalOperations;
+    function getReplaceOperations(indexPath, node) {
+      const operations = /* @__PURE__ */ new Map();
+      const [parentIndexPath, index] = splitIndexPath(indexPath);
+      for (let i = parentIndexPath.length - 1; i >= 0; i--) {
+        const parentKey = parentIndexPath.slice(0, i).join();
+        operations.set(parentKey, replaceOperation());
+      }
+      operations.set(parentIndexPath.join(), {
+        type: "removeThenInsert",
+        removeIndexes: [index],
+        insertIndex: index,
+        insertNodes: [node]
+      });
+      return operations;
+    }
+    exports2.getReplaceOperations = getReplaceOperations;
+    function applyOperations(node, operations, options) {
+      return (0, map_1.map)(node, Object.assign(Object.assign({}, options), {
+        // Avoid calling `getChildren` for every node in the tree.
+        // Return [] if we're just going to return the original node anyway.
+        getChildren: (node2, indexPath) => {
+          const key = indexPath.join();
+          const operation = operations.get(key);
+          switch (operation === null || operation === void 0 ? void 0 : operation.type) {
+            case "replace":
+            case "remove":
+            case "removeThenInsert":
+            case "insert":
+              return options.getChildren(node2, indexPath);
+            default:
+              return [];
+          }
+        },
+        transform: (node2, children, indexPath) => {
+          const key = indexPath.join();
+          const operation = operations.get(key);
+          switch (operation === null || operation === void 0 ? void 0 : operation.type) {
+            case "remove":
+              return options.create(node2, children.filter((_, index) => !operation.indexes.includes(index)), indexPath);
+            case "removeThenInsert":
+              const updatedChildren = children.filter((_, index) => !operation.removeIndexes.includes(index));
+              const adjustedIndex = operation.removeIndexes.reduce((index, removedIndex) => removedIndex < index ? index - 1 : index, operation.insertIndex);
+              return options.create(node2, splice(updatedChildren, adjustedIndex, 0, ...operation.insertNodes), indexPath);
+            case "insert":
+              return options.create(node2, splice(children, operation.index, 0, ...operation.nodes), indexPath);
+            case "replace":
+              return options.create(node2, children, indexPath);
+            default:
+              return node2;
+          }
+        }
+      }));
+    }
+    exports2.applyOperations = applyOperations;
+    function splice(array, start, deleteCount, ...items) {
+      return [
+        ...array.slice(0, start),
+        ...items,
+        ...array.slice(start + deleteCount)
+      ];
+    }
+    exports2.splice = splice;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/insert.js
+var require_insert = __commonJS({
+  "../../node_modules/tree-visit/lib/insert.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.insert = void 0;
+    var operation_1 = require_operation();
+    function insert(node, options) {
+      const { nodes, at } = options;
+      if (at.length === 0) {
+        throw new Error(`Can't insert nodes at the root`);
+      }
+      const state = (0, operation_1.getInsertionOperations)(at, nodes);
+      return (0, operation_1.applyOperations)(node, state, options);
+    }
+    exports2.insert = insert;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/move.js
+var require_move = __commonJS({
+  "../../node_modules/tree-visit/lib/move.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.move = void 0;
+    var access_1 = require_access();
+    var ancestors_1 = require_ancestors();
+    var operation_1 = require_operation();
+    function move(node, options) {
+      if (options.indexPaths.length === 0)
+        return node;
+      for (const indexPath of options.indexPaths) {
+        if (indexPath.length === 0) {
+          throw new Error(`Can't move the root node`);
+        }
+      }
+      if (options.to.length === 0) {
+        throw new Error(`Can't move nodes to the root`);
+      }
+      const _ancestorIndexPaths = (0, ancestors_1.ancestorIndexPaths)(options.indexPaths);
+      const nodesToInsert = _ancestorIndexPaths.map((indexPath) => (0, access_1.access)(node, indexPath, options));
+      const operations = (0, operation_1.getInsertionOperations)(options.to, nodesToInsert, (0, operation_1.getRemovalOperations)(_ancestorIndexPaths));
+      return (0, operation_1.applyOperations)(node, operations, options);
+    }
+    exports2.move = move;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/remove.js
+var require_remove = __commonJS({
+  "../../node_modules/tree-visit/lib/remove.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.remove = void 0;
+    var operation_1 = require_operation();
+    function remove(node, options) {
+      if (options.indexPaths.length === 0)
+        return node;
+      for (const indexPath of options.indexPaths) {
+        if (indexPath.length === 0) {
+          throw new Error(`Can't remove the root node`);
+        }
+      }
+      const operations = (0, operation_1.getRemovalOperations)(options.indexPaths);
+      return (0, operation_1.applyOperations)(node, operations, options);
+    }
+    exports2.remove = remove;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/replace.js
+var require_replace = __commonJS({
+  "../../node_modules/tree-visit/lib/replace.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.replace = void 0;
+    var operation_1 = require_operation();
+    function replace(node, options) {
+      if (options.at.length === 0)
+        return options.node;
+      const operations = (0, operation_1.getReplaceOperations)(options.at, options.node);
+      return (0, operation_1.applyOperations)(node, operations, options);
+    }
+    exports2.replace = replace;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/defineTree.js
+var require_defineTree = __commonJS({
+  "../../node_modules/tree-visit/lib/defineTree.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.defineTree = void 0;
+    var access_1 = require_access();
+    var diagram_1 = require_diagram();
+    var find_1 = require_find();
+    var flat_1 = require_flat();
+    var flatMap_1 = require_flatMap();
+    var insert_1 = require_insert();
+    var map_1 = require_map();
+    var move_1 = require_move();
+    var reduce_1 = require_reduce();
+    var remove_1 = require_remove();
+    var replace_1 = require_replace();
+    var visit_1 = require_visit();
+    var Tree = class _Tree {
+      constructor(getChildrenOrBaseOptions, appliedOptions) {
+        this.appliedOptions = appliedOptions;
+        this.getChildren = (node, indexPath, context) => {
+          return this._getChildren(node, indexPath, context);
+        };
+        this.mergeOptions = (options) => Object.assign(Object.assign(Object.assign({}, this.baseOptions), this.appliedOptions), options);
+        this.withOptions = (newOptions) => new _Tree(this.baseOptions, Object.assign(Object.assign({}, this.appliedOptions), newOptions));
+        this.access = (node, indexPath) => (0, access_1.access)(node, indexPath, this.mergeOptions({}));
+        this.accessPath = (node, indexPath) => (0, access_1.accessPath)(node, indexPath, this.mergeOptions({}));
+        this.diagram = (node, options) => typeof options === "function" ? (0, diagram_1.diagram)(node, this.mergeOptions({ getLabel: options })) : (0, diagram_1.diagram)(node, this.mergeOptions(options));
+        this.find = (node, predicateOrOptions) => typeof predicateOrOptions === "function" ? (0, find_1.find)(node, this.mergeOptions({ predicate: predicateOrOptions })) : (0, find_1.find)(node, this.mergeOptions(Object.assign({}, predicateOrOptions)));
+        this.findAll = (node, predicateOrOptions) => typeof predicateOrOptions === "function" ? (0, find_1.findAll)(node, this.mergeOptions({ predicate: predicateOrOptions })) : (0, find_1.findAll)(node, this.mergeOptions(Object.assign({}, predicateOrOptions)));
+        this.findIndexPath = (node, predicateOrOptions) => typeof predicateOrOptions === "function" ? (0, find_1.findIndexPath)(node, this.mergeOptions({ predicate: predicateOrOptions })) : (0, find_1.findIndexPath)(node, this.mergeOptions(Object.assign({}, predicateOrOptions)));
+        this.findAllIndexPaths = (node, predicateOrOptions) => typeof predicateOrOptions === "function" ? (0, find_1.findAllIndexPaths)(node, this.mergeOptions({ predicate: predicateOrOptions })) : (0, find_1.findAllIndexPaths)(node, this.mergeOptions(Object.assign({}, predicateOrOptions)));
+        this.flat = (node) => (0, flat_1.flat)(node, this.mergeOptions({}));
+        this.flatMap = (node, transform) => (0, flatMap_1.flatMap)(node, this.mergeOptions({ transform }));
+        this.reduce = (node, nextResult, initialResult) => (0, reduce_1.reduce)(node, this.mergeOptions({ nextResult, initialResult }));
+        this.map = (node, transform) => (0, map_1.map)(node, this.mergeOptions({ transform }));
+        this.visit = (node, onEnterOrOptions) => typeof onEnterOrOptions === "function" ? (0, visit_1.visit)(node, this.mergeOptions({ onEnter: onEnterOrOptions })) : (0, visit_1.visit)(node, this.mergeOptions(Object.assign({}, onEnterOrOptions)));
+        this.insert = (node, options) => (0, insert_1.insert)(node, this.mergeOptions(options));
+        this.remove = (node, options) => (0, remove_1.remove)(node, this.mergeOptions(options));
+        this.move = (node, options) => (0, move_1.move)(node, this.mergeOptions(options));
+        this.replace = (node, options) => (0, replace_1.replace)(node, this.mergeOptions(options));
+        this.baseOptions = typeof getChildrenOrBaseOptions === "function" ? { getChildren: getChildrenOrBaseOptions } : getChildrenOrBaseOptions;
+        this._getChildren = this.baseOptions.getChildren;
+      }
+    };
+    function defineTree2(getChildren) {
+      return new Tree(getChildren, {});
+    }
+    exports2.defineTree = defineTree2;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/indexPath.js
+var require_indexPath = __commonJS({
+  "../../node_modules/tree-visit/lib/indexPath.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/tree-visit/lib/options.js
+var require_options = __commonJS({
+  "../../node_modules/tree-visit/lib/options.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/tree-visit/lib/withOptions.js
+var require_withOptions = __commonJS({
+  "../../node_modules/tree-visit/lib/withOptions.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.withOptions = void 0;
+    var defineTree_1 = require_defineTree();
+    exports2.withOptions = defineTree_1.defineTree;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/tree-visit/lib/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_access(), exports2);
+    __exportStar(require_ancestors(), exports2);
+    __exportStar(require_defineTree(), exports2);
+    __exportStar(require_diagram(), exports2);
+    __exportStar(require_find(), exports2);
+    __exportStar(require_flat(), exports2);
+    __exportStar(require_flatMap(), exports2);
+    __exportStar(require_indexPath(), exports2);
+    __exportStar(require_insert(), exports2);
+    __exportStar(require_map(), exports2);
+    __exportStar(require_move(), exports2);
+    __exportStar(require_options(), exports2);
+    __exportStar(require_reduce(), exports2);
+    __exportStar(require_remove(), exports2);
+    __exportStar(require_replace(), exports2);
+    __exportStar(require_sort(), exports2);
+    __exportStar(require_visit(), exports2);
+    __exportStar(require_withOptions(), exports2);
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -52,18 +935,21 @@ __export(src_exports, {
   useColorScheme: () => useColorScheme,
   useConnectedUsersManager: () => useConnectedUsersManager,
   useCurrentUserId: () => useCurrentUserId,
+  useIOManager: () => useIOManager,
+  useInputs: () => useInputs,
   useIsInitialized: () => useIsInitialized,
   useManagedHistory: () => useManagedHistory,
   useManagedState: () => useManagedState,
   useMultiplayerState: () => useMultiplayerState,
   useNoyaState: () => useNoyaState,
   useObservable: () => useObservable,
+  useOutputTransforms: () => useOutputTransforms,
+  usePipelineManager: () => usePipelineManager,
   useSecret: () => useSecret,
   useSecretManager: () => useSecretManager,
   useSecrets: () => useSecrets,
   useSyncStateManager: () => useSyncStateManager,
-  useViewType: () => useViewType,
-  useWorkflowManager: () => useWorkflowManager
+  useViewType: () => useViewType
 });
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("@noya-app/state-manager"), module.exports);
@@ -459,10 +1345,13 @@ var StateInspector = (0, import_react_utils2.memoGeneric)(function StateInspecto
     secretManager,
     ephemeralUserDataManager,
     connectionEventManager,
-    taskManager
+    taskManager,
+    ioManager
   } = noyaManager;
   const [didMount, setDidMount] = import_react4.default.useState(false);
   const tasks = useObservable(taskManager.tasks$);
+  const inputs = useObservable(ioManager.inputs$);
+  const outputTransforms = useObservable(ioManager.outputTransforms$);
   (0, import_react4.useLayoutEffect)(() => {
     setDidMount(true);
   }, []);
@@ -504,6 +1393,14 @@ var StateInspector = (0, import_react_utils2.memoGeneric)(function StateInspecto
     "noya-multiplayer-react-show-secrets",
     false
   );
+  const [showInputs, setShowInputs] = useLocalStorageState(
+    "noya-multiplayer-react-show-inputs",
+    false
+  );
+  const [showOutputTransforms, setShowOutputTransforms] = useLocalStorageState(
+    "noya-multiplayer-react-show-output-transforms",
+    false
+  );
   const connectionEvents = useObservable(connectionEventManager.events$);
   (0, import_react4.useEffect)(() => {
     if (eventsContainerRef.current) {
@@ -522,6 +1419,10 @@ var StateInspector = (0, import_react_utils2.memoGeneric)(function StateInspecto
   const connectedUsers = useObservable(connectedUsersManager.connectedUsers$);
   const userId = useObservable(connectedUsersManager.currentUserId$);
   const state = useObservable(multiplayerStateManager.optimisticState$);
+  const inputsInitialized = useObservable(ioManager.inputsInitialized$);
+  const outputTransformsInitialized = useObservable(
+    ioManager.outputTransformsInitialized$
+  );
   (0, import_react4.useEffect)(() => {
     if (historyContainerRef.current) {
       historyContainerRef.current.scrollTop = historyContainerRef.current.scrollHeight;
@@ -895,33 +1796,6 @@ var StateInspector = (0, import_react_utils2.memoGeneric)(function StateInspecto
         "Delete"
       ))))
     ),
-    /* @__PURE__ */ import_react4.default.createElement(
-      DisclosureSection,
-      {
-        title: "Tasks",
-        colorScheme,
-        open: showTasks,
-        setOpen: setShowTasks
-      },
-      /* @__PURE__ */ import_react4.default.createElement("div", { style: styles.sectionInner }, tasks?.map((task) => /* @__PURE__ */ import_react4.default.createElement(
-        InspectorRow,
-        {
-          key: task.id,
-          colorScheme,
-          style: {
-            backgroundColor: task.status === "done" ? "rgba(0,255,0,0.2)" : task.status === "error" ? "rgba(255,0,0,0.2)" : void 0
-          }
-        },
-        /* @__PURE__ */ import_react4.default.createElement(
-          import_react_inspector.ObjectInspector,
-          {
-            name: task.name,
-            data: task.payload,
-            theme
-          }
-        )
-      )))
-    ),
     /* @__PURE__ */ import_react4.default.createElement(
       DisclosureSection,
       {
@@ -953,45 +1827,122 @@ var StateInspector = (0, import_react_utils2.memoGeneric)(function StateInspecto
         "Delete"
       ))))
     ),
+    " ",
     /* @__PURE__ */ import_react4.default.createElement(
       DisclosureSection,
       {
-        open: showEphemeral,
-        setOpen: setShowEphemeral,
-        title: "Ephemeral User Data",
+        open: showInputs,
+        setOpen: setShowInputs,
+        title: /* @__PURE__ */ import_react4.default.createElement(TitleLabel, null, "Inputs", /* @__PURE__ */ import_react4.default.createElement(ColoredDot, { type: inputsInitialized ? "success" : "error" })),
         colorScheme
       },
-      /* @__PURE__ */ import_react4.default.createElement("div", { style: styles.sectionInner }, Object.entries(ephemeral).map(([key, value]) => /* @__PURE__ */ import_react4.default.createElement(InspectorRow, { key, colorScheme }, /* @__PURE__ */ import_react4.default.createElement(
-        import_react_inspector.ObjectInspector,
+      /* @__PURE__ */ import_react4.default.createElement("div", { style: styles.sectionInner }, inputs?.map((input) => /* @__PURE__ */ import_react4.default.createElement(InspectorRow, { key: input.id, colorScheme }, /* @__PURE__ */ import_react4.default.createElement(import_react_inspector.ObjectInspector, { data: input, theme }))), !inputs?.length && /* @__PURE__ */ import_react4.default.createElement(
+        "div",
         {
-          name: key,
-          data: value,
-          theme,
-          expandLevel: 10
-        }
-      ))))
+          style: {
+            padding: "12px",
+            fontSize: "12px",
+            display: "flex",
+            flexDirection: "column",
+            gap: "4px"
+          }
+        },
+        /* @__PURE__ */ import_react4.default.createElement("span", null, "No inputs")
+      ))
     ),
     /* @__PURE__ */ import_react4.default.createElement(
       DisclosureSection,
       {
-        open: showEvents,
-        setOpen: setShowEvents,
-        title: "Events",
+        open: showOutputTransforms,
+        setOpen: setShowOutputTransforms,
+        title: /* @__PURE__ */ import_react4.default.createElement(TitleLabel, null, "Output Transforms", /* @__PURE__ */ import_react4.default.createElement(
+          ColoredDot,
+          {
+            type: outputTransformsInitialized ? "success" : "error"
+          }
+        )),
         colorScheme
       },
-      /* @__PURE__ */ import_react4.default.createElement("div", { ref: eventsContainerRef, style: styles.sectionInner }, connectionEvents?.map(
-        (event, index) => event.type === "stateChange" ? /* @__PURE__ */ import_react4.default.createElement(InspectorRow, { key: index, colorScheme }, "connection:", " ", /* @__PURE__ */ import_react4.default.createElement("span", { style: { fontStyle: "italic" } }, event.state.toLowerCase())) : /* @__PURE__ */ import_react4.default.createElement(
-          InspectorRow,
-          {
-            key: index,
-            colorScheme,
-            variant: event.type === "send" ? "up" : "down",
-            style: {
-              padding: "0px 12px 1px"
-            }
-          },
-          /* @__PURE__ */ import_react4.default.createElement(
-            import_react_inspector.ObjectInspector,
+      /* @__PURE__ */ import_react4.default.createElement("div", { style: styles.sectionInner }, outputTransforms?.map((transform) => /* @__PURE__ */ import_react4.default.createElement(InspectorRow, { key: transform.id, colorScheme }, /* @__PURE__ */ import_react4.default.createElement(import_react_inspector.ObjectInspector, { data: transform, theme }))), !outputTransforms?.length && /* @__PURE__ */ import_react4.default.createElement(
+        "div",
+        {
+          style: {
+            padding: "12px",
+            fontSize: "12px",
+            display: "flex",
+            flexDirection: "column",
+            gap: "4px"
+          }
+        },
+        /* @__PURE__ */ import_react4.default.createElement("span", null, "No output transforms")
+      ))
+    ),
+    /* @__PURE__ */ import_react4.default.createElement(
+      DisclosureSection,
+      {
+        title: "Tasks",
+        colorScheme,
+        open: showTasks,
+        setOpen: setShowTasks
+      },
+      /* @__PURE__ */ import_react4.default.createElement("div", { style: styles.sectionInner }, tasks?.map((task) => /* @__PURE__ */ import_react4.default.createElement(
+        InspectorRow,
+        {
+          key: task.id,
+          colorScheme,
+          style: {
+            backgroundColor: task.status === "done" ? "rgba(0,255,0,0.2)" : task.status === "error" ? "rgba(255,0,0,0.2)" : void 0
+          }
+        },
+        /* @__PURE__ */ import_react4.default.createElement(
+          import_react_inspector.ObjectInspector,
+          {
+            name: task.name,
+            data: task.payload,
+            theme
+          }
+        )
+      )))
+    ),
+    /* @__PURE__ */ import_react4.default.createElement(
+      DisclosureSection,
+      {
+        open: showEphemeral,
+        setOpen: setShowEphemeral,
+        title: "Ephemeral User Data",
+        colorScheme
+      },
+      /* @__PURE__ */ import_react4.default.createElement("div", { style: styles.sectionInner }, Object.entries(ephemeral).map(([key, value]) => /* @__PURE__ */ import_react4.default.createElement(InspectorRow, { key, colorScheme }, /* @__PURE__ */ import_react4.default.createElement(
+        import_react_inspector.ObjectInspector,
+        {
+          name: key,
+          data: value,
+          theme,
+          expandLevel: 10
+        }
+      ))))
+    ),
+    /* @__PURE__ */ import_react4.default.createElement(
+      DisclosureSection,
+      {
+        open: showEvents,
+        setOpen: setShowEvents,
+        title: "Events",
+        colorScheme
+      },
+      /* @__PURE__ */ import_react4.default.createElement("div", { ref: eventsContainerRef, style: styles.sectionInner }, connectionEvents?.map(
+        (event, index) => event.type === "stateChange" ? /* @__PURE__ */ import_react4.default.createElement(InspectorRow, { key: index, colorScheme }, "connection:", " ", /* @__PURE__ */ import_react4.default.createElement("span", { style: { fontStyle: "italic" } }, event.state.toLowerCase())) : /* @__PURE__ */ import_react4.default.createElement(
+          InspectorRow,
+          {
+            key: index,
+            colorScheme,
+            variant: event.type === "send" ? "up" : "down",
+            style: {
+              padding: "0px 12px 1px"
+            }
+          },
+          /* @__PURE__ */ import_react4.default.createElement(
+            import_react_inspector.ObjectInspector,
             {
               data: event.type === "error" ? event.error : event.message,
               theme,
@@ -1135,188 +2086,2919 @@ function SmallButton({
     children
   );
 }
-function ColoredDot({ type }) {
-  return /* @__PURE__ */ import_react4.default.createElement(
-    "span",
-    {
-      style: {
-        display: "inline-block",
-        width: 6,
-        height: 6,
-        background: type === "success" ? "rgba(0,200,0,0.8)" : "rgba(200,0,0,0.8)",
-        borderRadius: "50%",
-        verticalAlign: "middle"
-      }
-    }
-  );
+function ColoredDot({ type }) {
+  return /* @__PURE__ */ import_react4.default.createElement(
+    "span",
+    {
+      style: {
+        display: "inline-block",
+        width: 6,
+        height: 6,
+        background: type === "success" ? "rgba(0,200,0,0.8)" : "rgba(200,0,0,0.8)",
+        borderRadius: "50%",
+        verticalAlign: "middle"
+      }
+    }
+  );
+}
+function TitleLabel({ children }) {
+  return /* @__PURE__ */ import_react4.default.createElement("span", { style: { display: "flex", alignItems: "center", gap: "4px" } }, children);
+}
+
+// src/inspector/useStateInspector.tsx
+function createShadowRootElement() {
+  const host = document.createElement("div");
+  host.id = "noya-multiplayer-react-inspector-host";
+  const shadowRoot = host.attachShadow({ mode: "open" });
+  const container = document.createElement("div");
+  shadowRoot.appendChild(container);
+  return { host, container };
+}
+function useStateInspector({
+  noyaManager,
+  disabled = false,
+  colorScheme,
+  anchor
+}) {
+  const [root, setRoot] = import_react5.default.useState(null);
+  (0, import_react5.useLayoutEffect)(() => {
+    if (disabled) return;
+    const { host, container } = createShadowRootElement();
+    const root2 = (0, import_client.createRoot)(container);
+    document.body.appendChild(host);
+    setRoot(root2);
+    return () => {
+      document.body.removeChild(host);
+    };
+  }, [disabled]);
+  (0, import_react5.useLayoutEffect)(() => {
+    if (!root) return;
+    root.render(
+      /* @__PURE__ */ import_react5.default.createElement(
+        StateInspector,
+        {
+          colorScheme,
+          anchor,
+          noyaManager
+        }
+      )
+    );
+  }, [noyaManager, anchor, colorScheme, root]);
+}
+
+// src/hooks.ts
+function useSyncStateManager(stateManager, path) {
+  const getSnapshot = (0, import_react6.useCallback)(
+    () => typeof path === "string" ? stateManager.getState(path) : stateManager.getState(),
+    [stateManager, path]
+  );
+  return (0, import_react6.useSyncExternalStore)(
+    stateManager.addListener,
+    getSnapshot,
+    getSnapshot
+  );
+}
+function useManagedState(createInitialState, options) {
+  const [stateManager] = (0, import_react6.useState)(
+    () => new import_state_manager.StateManager(createInitialState(), options)
+  );
+  const state = useSyncStateManager(stateManager);
+  const setState = (0, import_react6.useCallback)(
+    (...args) => {
+      const [metadata, action] = args.length === 1 ? [void 0, args[0]] : args;
+      if (metadata === void 0) {
+        const performActionNoMetadata = stateManager.performAction;
+        if (action instanceof Function) {
+          performActionNoMetadata({
+            run: action,
+            undo: () => state
+          });
+        } else {
+          performActionNoMetadata({
+            run: () => action,
+            undo: () => state
+          });
+        }
+      } else {
+        const performActionWithMetadata = stateManager.performAction;
+        if (action instanceof Function) {
+          performActionWithMetadata(metadata, {
+            run: action,
+            undo: () => state
+          });
+        } else {
+          performActionWithMetadata(metadata, {
+            run: () => action,
+            undo: () => state
+          });
+        }
+      }
+    },
+    [state, stateManager]
+  );
+  return [state, setState, stateManager];
+}
+function useManagedHistory(stateManager) {
+  return (0, import_react6.useSyncExternalStore)(
+    stateManager.historyEmittor.addListener,
+    stateManager.getHistorySnapshot,
+    stateManager.getHistorySnapshot
+  );
+}
+var defaultStubSync = (0, import_state_manager.stubSync)();
+function useMultiplayerState(initialState, options) {
+  const {
+    sync = defaultStubSync,
+    inspector,
+    ...rest
+  } = options ?? {};
+  const [noyaManager] = (0, import_react6.useState)(
+    () => new import_state_manager.NoyaManager(initialState, rest)
+  );
+  const state = useObservable(
+    noyaManager.multiplayerStateManager.optimisticState$
+  );
+  const assets = useObservable(noyaManager.assetManager.assets$);
+  const extras = (0, import_react6.useMemo)(() => {
+    return {
+      noyaManager,
+      taskManager: noyaManager.taskManager,
+      connectionEventManager: noyaManager.connectionEventManager,
+      connectedUsersManager: noyaManager.connectedUsersManager,
+      ephemeralUserDataManager: noyaManager.ephemeralUserDataManager,
+      multiplayerStateManager: noyaManager.multiplayerStateManager,
+      assetManager: noyaManager.assetManager,
+      aiManager: noyaManager.aiManager,
+      rpcManager: noyaManager.rpcManager,
+      pipelineManager: noyaManager.pipelineManager,
+      secretManager: noyaManager.secretManager,
+      menuItemsManager: noyaManager.menuManager,
+      createAsset: noyaManager.assetManager.create,
+      deleteAsset: noyaManager.assetManager.delete,
+      assets
+    };
+  }, [noyaManager, assets]);
+  const syncRef = (0, import_react6.useRef)(sync);
+  (0, import_react6.useEffect)(() => {
+    if (syncRef.current) {
+      return syncRef.current({ noyaManager });
+    }
+  }, [noyaManager]);
+  useErrorOverlay(noyaManager);
+  useStateInspector({
+    noyaManager,
+    disabled: !inspector,
+    ...typeof inspector === "object" && inspector
+  });
+  return [state, noyaManager.multiplayerStateManager.setState, extras];
+}
+function useErrorOverlay(noyaManager) {
+  const unrecoverableError = useObservable(noyaManager.unrecoverableError);
+  (0, import_react6.useEffect)(() => {
+    if (!unrecoverableError) return;
+    const el = document.createElement("div");
+    el.id = "noya-multiplayer-react-error-overlay";
+    document.body.appendChild(el);
+    const root = (0, import_client2.createRoot)(el);
+    root.render((0, import_react6.createElement)(ErrorOverlay, { error: unrecoverableError }));
+    return () => {
+      root.unmount();
+      el.remove();
+    };
+  });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+var TransformKind = Symbol.for("TypeBox.Transform");
+var ReadonlyKind = Symbol.for("TypeBox.Readonly");
+var OptionalKind = Symbol.for("TypeBox.Optional");
+var Hint = Symbol.for("TypeBox.Hint");
+var Kind = Symbol.for("TypeBox.Kind");
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
+function Any(options = {}) {
+  return { ...options, [Kind]: "Any" };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+var value_exports = {};
+__export(value_exports, {
+  IsArray: () => IsArray,
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsDate: () => IsDate,
+  IsFunction: () => IsFunction,
+  IsIterator: () => IsIterator,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber,
+  IsObject: () => IsObject,
+  IsRegExp: () => IsRegExp,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  IsUint8Array: () => IsUint8Array,
+  IsUndefined: () => IsUndefined
+});
+function IsAsyncIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+}
+function IsArray(value) {
+  return Array.isArray(value);
+}
+function IsBigInt(value) {
+  return typeof value === "bigint";
+}
+function IsBoolean(value) {
+  return typeof value === "boolean";
+}
+function IsDate(value) {
+  return value instanceof globalThis.Date;
+}
+function IsFunction(value) {
+  return typeof value === "function";
+}
+function IsIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+function IsNull(value) {
+  return value === null;
+}
+function IsNumber(value) {
+  return typeof value === "number";
+}
+function IsObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function IsRegExp(value) {
+  return value instanceof globalThis.RegExp;
+}
+function IsString(value) {
+  return typeof value === "string";
+}
+function IsSymbol(value) {
+  return typeof value === "symbol";
+}
+function IsUint8Array(value) {
+  return value instanceof globalThis.Uint8Array;
+}
+function IsUndefined(value) {
+  return value === void 0;
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
+function ArrayType(value) {
+  return value.map((value2) => Visit(value2));
+}
+function DateType(value) {
+  return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+  return new Uint8Array(value);
+}
+function RegExpType(value) {
+  return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Visit(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Visit(value[key]);
+  }
+  return result;
+}
+function Visit(value) {
+  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
+}
+function Clone(value) {
+  return Visit(value);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
+function CloneRest(schemas) {
+  return schemas.map((schema) => CloneType(schema));
+}
+function CloneType(schema, options = {}) {
+  return { ...Clone(schema), ...options };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
+function Array2(schema, options = {}) {
+  return {
+    ...options,
+    [Kind]: "Array",
+    type: "array",
+    items: CloneType(schema)
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
+function AsyncIterator(items, options = {}) {
+  return {
+    ...options,
+    [Kind]: "AsyncIterator",
+    type: "AsyncIterator",
+    items: CloneType(items)
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs
+function DiscardKey(value, key) {
+  const { [key]: _, ...rest } = value;
+  return rest;
+}
+function Discard(value, keys) {
+  return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
+function Never(options = {}) {
+  return {
+    ...options,
+    [Kind]: "Never",
+    not: {}
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
+function MappedResult(properties) {
+  return {
+    [Kind]: "MappedResult",
+    properties
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
+function Constructor(parameters, returns, options) {
+  return {
+    ...options,
+    [Kind]: "Constructor",
+    type: "Constructor",
+    parameters: CloneRest(parameters),
+    returns: CloneType(returns)
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
+function Function2(parameters, returns, options) {
+  return {
+    ...options,
+    [Kind]: "Function",
+    type: "Function",
+    parameters: CloneRest(parameters),
+    returns: CloneType(returns)
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
+function UnionCreate(T, options) {
+  return { ...options, [Kind]: "Union", anyOf: CloneRest(T) };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
+function IsReadonly(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+}
+function IsOptional(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
+}
+function IsAny(value) {
+  return IsKindOf(value, "Any");
+}
+function IsArray2(value) {
+  return IsKindOf(value, "Array");
+}
+function IsAsyncIterator2(value) {
+  return IsKindOf(value, "AsyncIterator");
+}
+function IsBigInt2(value) {
+  return IsKindOf(value, "BigInt");
+}
+function IsBoolean2(value) {
+  return IsKindOf(value, "Boolean");
+}
+function IsConstructor(value) {
+  return IsKindOf(value, "Constructor");
+}
+function IsDate2(value) {
+  return IsKindOf(value, "Date");
+}
+function IsFunction2(value) {
+  return IsKindOf(value, "Function");
+}
+function IsInteger(value) {
+  return IsKindOf(value, "Integer");
+}
+function IsIntersect(value) {
+  return IsKindOf(value, "Intersect");
+}
+function IsIterator2(value) {
+  return IsKindOf(value, "Iterator");
+}
+function IsKindOf(value, kind) {
+  return IsObject(value) && Kind in value && value[Kind] === kind;
+}
+function IsLiteral(value) {
+  return IsKindOf(value, "Literal");
+}
+function IsMappedKey(value) {
+  return IsKindOf(value, "MappedKey");
+}
+function IsMappedResult(value) {
+  return IsKindOf(value, "MappedResult");
+}
+function IsNever(value) {
+  return IsKindOf(value, "Never");
+}
+function IsNot(value) {
+  return IsKindOf(value, "Not");
+}
+function IsNull2(value) {
+  return IsKindOf(value, "Null");
+}
+function IsNumber2(value) {
+  return IsKindOf(value, "Number");
+}
+function IsObject2(value) {
+  return IsKindOf(value, "Object");
+}
+function IsPromise(value) {
+  return IsKindOf(value, "Promise");
+}
+function IsRecord(value) {
+  return IsKindOf(value, "Record");
+}
+function IsRef(value) {
+  return IsKindOf(value, "Ref");
+}
+function IsRegExp2(value) {
+  return IsKindOf(value, "RegExp");
+}
+function IsString2(value) {
+  return IsKindOf(value, "String");
+}
+function IsSymbol2(value) {
+  return IsKindOf(value, "Symbol");
+}
+function IsTemplateLiteral(value) {
+  return IsKindOf(value, "TemplateLiteral");
+}
+function IsThis(value) {
+  return IsKindOf(value, "This");
+}
+function IsTransform(value) {
+  return IsObject(value) && TransformKind in value;
+}
+function IsTuple(value) {
+  return IsKindOf(value, "Tuple");
+}
+function IsUndefined2(value) {
+  return IsKindOf(value, "Undefined");
+}
+function IsUnion(value) {
+  return IsKindOf(value, "Union");
+}
+function IsUint8Array2(value) {
+  return IsKindOf(value, "Uint8Array");
+}
+function IsUnknown(value) {
+  return IsKindOf(value, "Unknown");
+}
+function IsUnsafe(value) {
+  return IsKindOf(value, "Unsafe");
+}
+function IsVoid(value) {
+  return IsKindOf(value, "Void");
+}
+function IsKind(value) {
+  return IsObject(value) && Kind in value && IsString(value[Kind]);
+}
+function IsSchema(value) {
+  return IsAny(value) || IsArray2(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber2(value) || IsObject2(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined2(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
+function IsUnionOptional(T) {
+  return T.some((L) => IsOptional(L));
+}
+function RemoveOptionalFromRest(T) {
+  return T.map((L) => IsOptional(L) ? RemoveOptionalFromType(L) : L);
+}
+function RemoveOptionalFromType(T) {
+  return Discard(T, [OptionalKind]);
+}
+function ResolveUnion(T, options) {
+  return IsUnionOptional(T) ? Optional(UnionCreate(RemoveOptionalFromRest(T), options)) : UnionCreate(RemoveOptionalFromRest(T), options);
+}
+function UnionEvaluated(T, options = {}) {
+  return T.length === 0 ? Never(options) : T.length === 1 ? CloneType(T[0], options) : ResolveUnion(T, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/union/union.mjs
+function Union(T, options = {}) {
+  return T.length === 0 ? Never(options) : T.length === 1 ? CloneType(T[0], options) : UnionCreate(T, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
+var TypeBoxError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs
+var TemplateLiteralParserError = class extends TypeBoxError {
+};
+function Unescape(pattern) {
+  return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
+}
+function IsNonEscaped(pattern, index, char) {
+  return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+  return IsNonEscaped(pattern, index, "(");
+}
+function IsCloseParen(pattern, index) {
+  return IsNonEscaped(pattern, index, ")");
+}
+function IsSeparator(pattern, index) {
+  return IsNonEscaped(pattern, index, "|");
+}
+function IsGroup(pattern) {
+  if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+    return false;
+  let count = 0;
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (count === 0 && index !== pattern.length - 1)
+      return false;
+  }
+  return true;
+}
+function InGroup(pattern) {
+  return pattern.slice(1, pattern.length - 1);
+}
+function IsPrecedenceOr(pattern) {
+  let count = 0;
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (IsSeparator(pattern, index) && count === 0)
+      return true;
+  }
+  return false;
+}
+function IsPrecedenceAnd(pattern) {
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      return true;
+  }
+  return false;
+}
+function Or(pattern) {
+  let [count, start] = [0, 0];
+  const expressions = [];
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (IsSeparator(pattern, index) && count === 0) {
+      const range2 = pattern.slice(start, index);
+      if (range2.length > 0)
+        expressions.push(TemplateLiteralParse(range2));
+      start = index + 1;
+    }
+  }
+  const range = pattern.slice(start);
+  if (range.length > 0)
+    expressions.push(TemplateLiteralParse(range));
+  if (expressions.length === 0)
+    return { type: "const", const: "" };
+  if (expressions.length === 1)
+    return expressions[0];
+  return { type: "or", expr: expressions };
+}
+function And(pattern) {
+  function Group(value, index) {
+    if (!IsOpenParen(value, index))
+      throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+    let count = 0;
+    for (let scan = index; scan < value.length; scan++) {
+      if (IsOpenParen(value, scan))
+        count += 1;
+      if (IsCloseParen(value, scan))
+        count -= 1;
+      if (count === 0)
+        return [index, scan];
+    }
+    throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+  }
+  function Range(pattern2, index) {
+    for (let scan = index; scan < pattern2.length; scan++) {
+      if (IsOpenParen(pattern2, scan))
+        return [index, scan];
+    }
+    return [index, pattern2.length];
+  }
+  const expressions = [];
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) {
+      const [start, end] = Group(pattern, index);
+      const range = pattern.slice(start, end + 1);
+      expressions.push(TemplateLiteralParse(range));
+      index = end;
+    } else {
+      const [start, end] = Range(pattern, index);
+      const range = pattern.slice(start, end);
+      if (range.length > 0)
+        expressions.push(TemplateLiteralParse(range));
+      index = end - 1;
+    }
+  }
+  return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
+}
+function TemplateLiteralParse(pattern) {
+  return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: Unescape(pattern) };
+}
+function TemplateLiteralParseExact(pattern) {
+  return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.mjs
+var TemplateLiteralFiniteError = class extends TypeBoxError {
+};
+function IsNumberExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+}
+function IsBooleanExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+}
+function IsStringExpression(expression) {
+  return expression.type === "const" && expression.const === ".*";
+}
+function IsTemplateLiteralExpressionFinite(expression) {
+  return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
+    throw new TemplateLiteralFiniteError(`Unknown expression type`);
+  })();
+}
+function IsTemplateLiteralFinite(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs
+var TemplateLiteralGenerateError = class extends TypeBoxError {
+};
+function* GenerateReduce(buffer) {
+  if (buffer.length === 1)
+    return yield* buffer[0];
+  for (const left of buffer[0]) {
+    for (const right of GenerateReduce(buffer.slice(1))) {
+      yield `${left}${right}`;
+    }
+  }
+}
+function* GenerateAnd(expression) {
+  return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+}
+function* GenerateOr(expression) {
+  for (const expr of expression.expr)
+    yield* TemplateLiteralExpressionGenerate(expr);
+}
+function* GenerateConst(expression) {
+  return yield expression.const;
+}
+function* TemplateLiteralExpressionGenerate(expression) {
+  return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
+    throw new TemplateLiteralGenerateError("Unknown expression");
+  })();
+}
+function TemplateLiteralGenerate(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/literal/literal.mjs
+function Literal(value, options = {}) {
+  return {
+    ...options,
+    [Kind]: "Literal",
+    const: value,
+    type: typeof value
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
+function Boolean(options = {}) {
+  return {
+    ...options,
+    [Kind]: "Boolean",
+    type: "boolean"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs
+function BigInt2(options = {}) {
+  return {
+    ...options,
+    [Kind]: "BigInt",
+    type: "bigint"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/number/number.mjs
+function Number2(options = {}) {
+  return {
+    ...options,
+    [Kind]: "Number",
+    type: "number"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/string/string.mjs
+function String(options = {}) {
+  return { ...options, [Kind]: "String", type: "string" };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
+function* FromUnion(syntax) {
+  const trim = syntax.trim().replace(/"|'/g, "");
+  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt2() : trim === "string" ? yield String() : yield (() => {
+    const literals = trim.split("|").map((literal) => Literal(literal.trim()));
+    return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
+  })();
+}
+function* FromTerminal(syntax) {
+  if (syntax[1] !== "{") {
+    const L = Literal("$");
+    const R = FromSyntax(syntax.slice(1));
+    return yield* [L, ...R];
+  }
+  for (let i = 2; i < syntax.length; i++) {
+    if (syntax[i] === "}") {
+      const L = FromUnion(syntax.slice(2, i));
+      const R = FromSyntax(syntax.slice(i + 1));
+      return yield* [...L, ...R];
+    }
+  }
+  yield Literal(syntax);
+}
+function* FromSyntax(syntax) {
+  for (let i = 0; i < syntax.length; i++) {
+    if (syntax[i] === "$") {
+      const L = Literal(syntax.slice(0, i));
+      const R = FromTerminal(syntax.slice(i));
+      return yield* [L, ...R];
+    }
+  }
+  yield Literal(syntax);
+}
+function TemplateLiteralSyntax(syntax) {
+  return [...FromSyntax(syntax)];
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
+var PatternBoolean = "(true|false)";
+var PatternNumber = "(0|[1-9][0-9]*)";
+var PatternString = "(.*)";
+var PatternBooleanExact = `^${PatternBoolean}$`;
+var PatternNumberExact = `^${PatternNumber}$`;
+var PatternStringExact = `^${PatternString}$`;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.mjs
+var TemplateLiteralPatternError = class extends TypeBoxError {
+};
+function Escape(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function Visit2(schema, acc) {
+  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber2(schema) ? `${acc}${PatternNumber}` : IsInteger(schema) ? `${acc}${PatternNumber}` : IsBigInt2(schema) ? `${acc}${PatternNumber}` : IsString2(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean2(schema) ? `${acc}${PatternBoolean}` : (() => {
+    throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
+  })();
+}
+function TemplateLiteralPattern(kinds) {
+  return `^${kinds.map((schema) => Visit2(schema, "")).join("")}$`;
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/union.mjs
+function TemplateLiteralToUnion(schema) {
+  const R = TemplateLiteralGenerate(schema);
+  const L = R.map((S) => Literal(S));
+  return UnionEvaluated(L);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.mjs
+function TemplateLiteral(unresolved, options = {}) {
+  const pattern = IsString(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
+  return { ...options, [Kind]: "TemplateLiteral", type: "string", pattern };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
+function FromTemplateLiteral(T) {
+  const R = TemplateLiteralGenerate(T);
+  return R.map((S) => S.toString());
+}
+function FromUnion2(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...IndexPropertyKeys(L));
+  return Acc;
+}
+function FromLiteral(T) {
+  return [T.toString()];
+}
+function IndexPropertyKeys(T) {
+  return [...new Set(IsTemplateLiteral(T) ? FromTemplateLiteral(T) : IsUnion(T) ? FromUnion2(T.anyOf) : IsLiteral(T) ? FromLiteral(T.const) : IsNumber2(T) ? ["[number]"] : IsInteger(T) ? ["[number]"] : [])];
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
+function FromProperties(T, P, options) {
+  const Acc = {};
+  for (const K2 of Object.getOwnPropertyNames(P)) {
+    Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options);
+  }
+  return Acc;
+}
+function FromMappedResult(T, R, options) {
+  return FromProperties(T, R.properties, options);
+}
+function IndexFromMappedResult(T, R, options) {
+  const P = FromMappedResult(T, R, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs
+function FromRest(T, K) {
+  return T.map((L) => IndexFromPropertyKey(L, K));
+}
+function FromIntersectRest(T) {
+  return T.filter((L) => !IsNever(L));
+}
+function FromIntersect(T, K) {
+  return IntersectEvaluated(FromIntersectRest(FromRest(T, K)));
+}
+function FromUnionRest(T) {
+  return T.some((L) => IsNever(L)) ? [] : T;
+}
+function FromUnion3(T, K) {
+  return UnionEvaluated(FromUnionRest(FromRest(T, K)));
+}
+function FromTuple(T, K) {
+  return K in T ? T[K] : K === "[number]" ? UnionEvaluated(T) : Never();
+}
+function FromArray(T, K) {
+  return K === "[number]" ? T : Never();
+}
+function FromProperty(T, K) {
+  return K in T ? T[K] : Never();
+}
+function IndexFromPropertyKey(T, K) {
+  return IsIntersect(T) ? FromIntersect(T.allOf, K) : IsUnion(T) ? FromUnion3(T.anyOf, K) : IsTuple(T) ? FromTuple(T.items ?? [], K) : IsArray2(T) ? FromArray(T.items, K) : IsObject2(T) ? FromProperty(T.properties, K) : Never();
+}
+function IndexFromPropertyKeys(T, K) {
+  return K.map((L) => IndexFromPropertyKey(T, L));
+}
+function FromSchema(T, K) {
+  return UnionEvaluated(IndexFromPropertyKeys(T, K));
+}
+function Index(T, K, options = {}) {
+  return IsMappedResult(K) ? CloneType(IndexFromMappedResult(T, K, options)) : IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) : IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) : CloneType(FromSchema(T, K), options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
+function MappedIndexPropertyKey(T, K, options) {
+  return { [K]: Index(T, [K], options) };
+}
+function MappedIndexPropertyKeys(T, K, options) {
+  return K.reduce((Acc, L) => {
+    return { ...Acc, ...MappedIndexPropertyKey(T, L, options) };
+  }, {});
+}
+function MappedIndexProperties(T, K, options) {
+  return MappedIndexPropertyKeys(T, K.keys, options);
+}
+function IndexFromMappedKey(T, K, options) {
+  const P = MappedIndexProperties(T, K, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.mjs
+function Iterator(items, options = {}) {
+  return {
+    ...options,
+    [Kind]: "Iterator",
+    type: "Iterator",
+    items: CloneType(items)
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
+function _Object(properties, options = {}) {
+  const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
+  const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]));
+  const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
+  const clonedAdditionalProperties = IsSchema(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
+  const clonedProperties = {};
+  for (const key of propertyKeys)
+    clonedProperties[key] = CloneType(properties[key]);
+  return requiredKeys.length > 0 ? { ...options, ...clonedAdditionalProperties, [Kind]: "Object", type: "object", properties: clonedProperties, required: requiredKeys } : { ...options, ...clonedAdditionalProperties, [Kind]: "Object", type: "object", properties: clonedProperties };
+}
+var Object2 = _Object;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
+function Promise2(item, options = {}) {
+  return {
+    ...options,
+    [Kind]: "Promise",
+    type: "Promise",
+    item: CloneType(item)
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.mjs
+function RemoveReadonly(schema) {
+  return Discard(CloneType(schema), [ReadonlyKind]);
+}
+function AddReadonly(schema) {
+  return { ...CloneType(schema), [ReadonlyKind]: "Readonly" };
+}
+function ReadonlyWithFlag(schema, F) {
+  return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
+}
+function Readonly(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
+function FromProperties2(K, F) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Readonly(K[K2], F);
+  return Acc;
+}
+function FromMappedResult2(R, F) {
+  return FromProperties2(R.properties, F);
+}
+function ReadonlyFromMappedResult(R, F) {
+  const P = FromMappedResult2(R, F);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs
+function Tuple(items, options = {}) {
+  const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+  return items.length > 0 ? { ...options, [Kind]: "Tuple", type: "array", items: CloneRest(items), additionalItems, minItems, maxItems } : { ...options, [Kind]: "Tuple", type: "array", minItems, maxItems };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
+function SetIncludes(T, S) {
+  return T.includes(S);
+}
+function SetDistinct(T) {
+  return [...new Set(T)];
+}
+function SetIntersect(T, S) {
+  return T.filter((L) => S.includes(L));
+}
+function SetIntersectManyResolve(T, Init) {
+  return T.reduce((Acc, L) => {
+    return SetIntersect(Acc, L);
+  }, Init);
+}
+function SetIntersectMany(T) {
+  return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
+}
+function SetUnionMany(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...L);
+  return Acc;
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.mjs
+function FromMappedResult3(K, P) {
+  return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
+}
+function MappedKeyToKnownMappedResultProperties(K) {
+  return { [K]: Literal(K) };
+}
+function MappedKeyToUnknownMappedResultProperties(P) {
+  const Acc = {};
+  for (const L of P)
+    Acc[L] = Literal(L);
+  return Acc;
+}
+function MappedKeyToMappedResultProperties(K, P) {
+  return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
+}
+function FromMappedKey(K, P) {
+  const R = MappedKeyToMappedResultProperties(K, P);
+  return FromMappedResult3(K, R);
+}
+function FromRest2(K, T) {
+  return T.map((L) => FromSchemaType(K, L));
+}
+function FromProperties3(K, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+    Acc[K2] = FromSchemaType(K, T[K2]);
+  return Acc;
+}
+function FromSchemaType(K, T) {
+  return (
+    // unevaluated modifier types
+    IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : (
+      // unevaluated mapped types
+      IsMappedResult(T) ? FromMappedResult3(K, T.properties) : IsMappedKey(T) ? FromMappedKey(K, T.keys) : (
+        // unevaluated types
+        IsConstructor(T) ? Constructor(FromRest2(K, T.parameters), FromSchemaType(K, T.returns)) : IsFunction2(T) ? Function2(FromRest2(K, T.parameters), FromSchemaType(K, T.returns)) : IsAsyncIterator2(T) ? AsyncIterator(FromSchemaType(K, T.items)) : IsIterator2(T) ? Iterator(FromSchemaType(K, T.items)) : IsIntersect(T) ? Intersect(FromRest2(K, T.allOf)) : IsUnion(T) ? Union(FromRest2(K, T.anyOf)) : IsTuple(T) ? Tuple(FromRest2(K, T.items ?? [])) : IsObject2(T) ? Object2(FromProperties3(K, T.properties)) : IsArray2(T) ? Array2(FromSchemaType(K, T.items)) : IsPromise(T) ? Promise2(FromSchemaType(K, T.item)) : T
+      )
+    )
+  );
+}
+function MappedFunctionReturnType(K, T) {
+  const Acc = {};
+  for (const L of K)
+    Acc[L] = FromSchemaType(L, T);
+  return Acc;
+}
+function Mapped(key, map3, options = {}) {
+  const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const RT = map3({ [Kind]: "MappedKey", keys: K });
+  const R = MappedFunctionReturnType(K, RT);
+  return CloneType(Object2(R), options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/optional/optional.mjs
+function RemoveOptional(schema) {
+  return Discard(CloneType(schema), [OptionalKind]);
+}
+function AddOptional(schema) {
+  return { ...CloneType(schema), [OptionalKind]: "Optional" };
+}
+function OptionalWithFlag(schema, F) {
+  return F === false ? RemoveOptional(schema) : AddOptional(schema);
+}
+function Optional(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
+function FromProperties4(P, F) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Optional(P[K2], F);
+  return Acc;
+}
+function FromMappedResult4(R, F) {
+  return FromProperties4(R.properties, F);
+}
+function OptionalFromMappedResult(R, F) {
+  const P = FromMappedResult4(R, F);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
+function IntersectCreate(T, options) {
+  const allObjects = T.every((schema) => IsObject2(schema));
+  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) } : {};
+  return options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? { ...options, ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: CloneRest(T) } : { ...options, ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: CloneRest(T) };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
+function IsIntersectOptional(T) {
+  return T.every((L) => IsOptional(L));
+}
+function RemoveOptionalFromType2(T) {
+  return Discard(T, [OptionalKind]);
+}
+function RemoveOptionalFromRest2(T) {
+  return T.map((L) => IsOptional(L) ? RemoveOptionalFromType2(L) : L);
+}
+function ResolveIntersect(T, options) {
+  return IsIntersectOptional(T) ? Optional(IntersectCreate(RemoveOptionalFromRest2(T), options)) : IntersectCreate(RemoveOptionalFromRest2(T), options);
+}
+function IntersectEvaluated(T, options = {}) {
+  if (T.length === 0)
+    return Never(options);
+  if (T.length === 1)
+    return CloneType(T[0], options);
+  if (T.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return ResolveIntersect(T, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
+function Intersect(T, options = {}) {
+  if (T.length === 0)
+    return Never(options);
+  if (T.length === 1)
+    return CloneType(T[0], options);
+  if (T.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return IntersectCreate(T, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs
+function FromRest3(T) {
+  return T.map((L) => AwaitedResolve(L));
+}
+function FromIntersect2(T) {
+  return Intersect(FromRest3(T));
+}
+function FromUnion4(T) {
+  return Union(FromRest3(T));
+}
+function FromPromise(T) {
+  return AwaitedResolve(T);
+}
+function AwaitedResolve(T) {
+  return IsIntersect(T) ? FromIntersect2(T.allOf) : IsUnion(T) ? FromUnion4(T.anyOf) : IsPromise(T) ? FromPromise(T.item) : T;
+}
+function Awaited(T, options = {}) {
+  return CloneType(AwaitedResolve(T), options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
+function FromRest4(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(KeyOfPropertyKeys(L));
+  return Acc;
+}
+function FromIntersect3(T) {
+  const C = FromRest4(T);
+  const R = SetUnionMany(C);
+  return R;
+}
+function FromUnion5(T) {
+  const C = FromRest4(T);
+  const R = SetIntersectMany(C);
+  return R;
+}
+function FromTuple2(T) {
+  return T.map((_, I) => I.toString());
+}
+function FromArray2(_) {
+  return ["[number]"];
+}
+function FromProperties5(T) {
+  return globalThis.Object.getOwnPropertyNames(T);
+}
+function FromPatternProperties(patternProperties) {
+  if (!includePatternProperties)
+    return [];
+  const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties);
+  return patternPropertyKeys.map((key) => {
+    return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
+  });
+}
+function KeyOfPropertyKeys(T) {
+  return IsIntersect(T) ? FromIntersect3(T.allOf) : IsUnion(T) ? FromUnion5(T.anyOf) : IsTuple(T) ? FromTuple2(T.items ?? []) : IsArray2(T) ? FromArray2(T.items) : IsObject2(T) ? FromProperties5(T.properties) : IsRecord(T) ? FromPatternProperties(T.patternProperties) : [];
+}
+var includePatternProperties = false;
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.mjs
+function KeyOfPropertyKeysToRest(T) {
+  return T.map((L) => L === "[number]" ? Number2() : Literal(L));
+}
+function KeyOf(T, options = {}) {
+  if (IsMappedResult(T)) {
+    return KeyOfFromMappedResult(T, options);
+  } else {
+    const K = KeyOfPropertyKeys(T);
+    const S = KeyOfPropertyKeysToRest(K);
+    const U = UnionEvaluated(S);
+    return CloneType(U, options);
+  }
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
+function FromProperties6(K, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = KeyOf(K[K2], options);
+  return Acc;
+}
+function FromMappedResult5(R, options) {
+  return FromProperties6(R.properties, options);
+}
+function KeyOfFromMappedResult(R, options) {
+  const P = FromMappedResult5(R, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs
+function CompositeKeys(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...KeyOfPropertyKeys(L));
+  return SetDistinct(Acc);
+}
+function FilterNever(T) {
+  return T.filter((L) => !IsNever(L));
+}
+function CompositeProperty(T, K) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...IndexFromPropertyKeys(L, [K]));
+  return FilterNever(Acc);
+}
+function CompositeProperties(T, K) {
+  const Acc = {};
+  for (const L of K) {
+    Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+  }
+  return Acc;
+}
+function Composite(T, options = {}) {
+  const K = CompositeKeys(T);
+  const P = CompositeProperties(T, K);
+  const R = Object2(P, options);
+  return R;
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/date/date.mjs
+function Date2(options = {}) {
+  return {
+    ...options,
+    [Kind]: "Date",
+    type: "Date"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/null/null.mjs
+function Null(options = {}) {
+  return {
+    ...options,
+    [Kind]: "Null",
+    type: "null"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs
+function Symbol2(options) {
+  return { ...options, [Kind]: "Symbol", type: "symbol" };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs
+function Undefined(options = {}) {
+  return { ...options, [Kind]: "Undefined", type: "undefined" };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs
+function Uint8Array2(options = {}) {
+  return { ...options, [Kind]: "Uint8Array", type: "Uint8Array" };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs
+function Unknown(options = {}) {
+  return {
+    ...options,
+    [Kind]: "Unknown"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/const/const.mjs
+function FromArray3(T) {
+  return T.map((L) => FromValue(L, false));
+}
+function FromProperties7(value) {
+  const Acc = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(value))
+    Acc[K] = Readonly(FromValue(value[K], false));
+  return Acc;
+}
+function ConditionalReadonly(T, root) {
+  return root === true ? T : Readonly(T);
+}
+function FromValue(value, root) {
+  return IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) : IsIterator(value) ? ConditionalReadonly(Any(), root) : IsArray(value) ? Readonly(Tuple(FromArray3(value))) : IsUint8Array(value) ? Uint8Array2() : IsDate(value) ? Date2() : IsObject(value) ? ConditionalReadonly(Object2(FromProperties7(value)), root) : IsFunction(value) ? ConditionalReadonly(Function2([], Unknown()), root) : IsUndefined(value) ? Undefined() : IsNull(value) ? Null() : IsSymbol(value) ? Symbol2() : IsBigInt(value) ? BigInt2() : IsNumber(value) ? Literal(value) : IsBoolean(value) ? Literal(value) : IsString(value) ? Literal(value) : Object2({});
+}
+function Const(T, options = {}) {
+  return CloneType(FromValue(T, true), options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
+function ConstructorParameters(schema, options = {}) {
+  return Tuple(CloneRest(schema.parameters), { ...options });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/deref/deref.mjs
+function FromRest5(schema, references) {
+  return schema.map((schema2) => Deref(schema2, references));
+}
+function FromProperties8(properties, references) {
+  const Acc = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties)) {
+    Acc[K] = Deref(properties[K], references);
+  }
+  return Acc;
+}
+function FromConstructor(schema, references) {
+  schema.parameters = FromRest5(schema.parameters, references);
+  schema.returns = Deref(schema.returns, references);
+  return schema;
+}
+function FromFunction(schema, references) {
+  schema.parameters = FromRest5(schema.parameters, references);
+  schema.returns = Deref(schema.returns, references);
+  return schema;
+}
+function FromIntersect4(schema, references) {
+  schema.allOf = FromRest5(schema.allOf, references);
+  return schema;
+}
+function FromUnion6(schema, references) {
+  schema.anyOf = FromRest5(schema.anyOf, references);
+  return schema;
+}
+function FromTuple3(schema, references) {
+  if (IsUndefined(schema.items))
+    return schema;
+  schema.items = FromRest5(schema.items, references);
+  return schema;
+}
+function FromArray4(schema, references) {
+  schema.items = Deref(schema.items, references);
+  return schema;
+}
+function FromObject(schema, references) {
+  schema.properties = FromProperties8(schema.properties, references);
+  return schema;
+}
+function FromPromise2(schema, references) {
+  schema.item = Deref(schema.item, references);
+  return schema;
+}
+function FromAsyncIterator(schema, references) {
+  schema.items = Deref(schema.items, references);
+  return schema;
+}
+function FromIterator(schema, references) {
+  schema.items = Deref(schema.items, references);
+  return schema;
+}
+function FromRef(schema, references) {
+  const target = references.find((remote) => remote.$id === schema.$ref);
+  if (target === void 0)
+    throw Error(`Unable to dereference schema with $id ${schema.$ref}`);
+  const discard = Discard(target, ["$id"]);
+  return Deref(discard, references);
+}
+function DerefResolve(schema, references) {
+  return IsConstructor(schema) ? FromConstructor(schema, references) : IsFunction2(schema) ? FromFunction(schema, references) : IsIntersect(schema) ? FromIntersect4(schema, references) : IsUnion(schema) ? FromUnion6(schema, references) : IsTuple(schema) ? FromTuple3(schema, references) : IsArray2(schema) ? FromArray4(schema, references) : IsObject2(schema) ? FromObject(schema, references) : IsPromise(schema) ? FromPromise2(schema, references) : IsAsyncIterator2(schema) ? FromAsyncIterator(schema, references) : IsIterator2(schema) ? FromIterator(schema, references) : IsRef(schema) ? FromRef(schema, references) : schema;
+}
+function Deref(schema, references) {
+  return DerefResolve(CloneType(schema), CloneRest(references));
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
+function Enum(item, options = {}) {
+  if (IsUndefined(item))
+    throw new Error("Enum undefined or empty");
+  const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+  const values2 = [...new Set(values1)];
+  const anyOf = values2.map((value) => Literal(value));
+  return Union(anyOf, { ...options, [Hint]: "Enum" });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
+var type_exports = {};
+__export(type_exports, {
+  IsAny: () => IsAny2,
+  IsArray: () => IsArray3,
+  IsAsyncIterator: () => IsAsyncIterator3,
+  IsBigInt: () => IsBigInt3,
+  IsBoolean: () => IsBoolean3,
+  IsConstructor: () => IsConstructor2,
+  IsDate: () => IsDate3,
+  IsFunction: () => IsFunction3,
+  IsInteger: () => IsInteger2,
+  IsIntersect: () => IsIntersect2,
+  IsIterator: () => IsIterator3,
+  IsKind: () => IsKind2,
+  IsKindOf: () => IsKindOf2,
+  IsLiteral: () => IsLiteral2,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralValue: () => IsLiteralValue,
+  IsMappedKey: () => IsMappedKey2,
+  IsMappedResult: () => IsMappedResult2,
+  IsNever: () => IsNever2,
+  IsNot: () => IsNot2,
+  IsNull: () => IsNull3,
+  IsNumber: () => IsNumber3,
+  IsObject: () => IsObject3,
+  IsOptional: () => IsOptional2,
+  IsPromise: () => IsPromise2,
+  IsProperties: () => IsProperties,
+  IsReadonly: () => IsReadonly2,
+  IsRecord: () => IsRecord2,
+  IsRecursive: () => IsRecursive,
+  IsRef: () => IsRef2,
+  IsRegExp: () => IsRegExp3,
+  IsSchema: () => IsSchema2,
+  IsString: () => IsString3,
+  IsSymbol: () => IsSymbol3,
+  IsTemplateLiteral: () => IsTemplateLiteral2,
+  IsThis: () => IsThis2,
+  IsTransform: () => IsTransform2,
+  IsTuple: () => IsTuple2,
+  IsUint8Array: () => IsUint8Array3,
+  IsUndefined: () => IsUndefined3,
+  IsUnion: () => IsUnion2,
+  IsUnionLiteral: () => IsUnionLiteral,
+  IsUnknown: () => IsUnknown2,
+  IsUnsafe: () => IsUnsafe2,
+  IsVoid: () => IsVoid2,
+  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
+});
+var TypeGuardUnknownTypeError = class extends TypeBoxError {
+};
+var KnownTypes = [
+  "Any",
+  "Array",
+  "AsyncIterator",
+  "BigInt",
+  "Boolean",
+  "Constructor",
+  "Date",
+  "Enum",
+  "Function",
+  "Integer",
+  "Intersect",
+  "Iterator",
+  "Literal",
+  "MappedKey",
+  "MappedResult",
+  "Not",
+  "Null",
+  "Number",
+  "Object",
+  "Promise",
+  "Record",
+  "Ref",
+  "RegExp",
+  "String",
+  "Symbol",
+  "TemplateLiteral",
+  "This",
+  "Tuple",
+  "Undefined",
+  "Union",
+  "Uint8Array",
+  "Unknown",
+  "Void"
+];
+function IsPattern(value) {
+  try {
+    new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function IsControlCharacterFree(value) {
+  if (!IsString(value))
+    return false;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+      return false;
+    }
+  }
+  return true;
+}
+function IsAdditionalProperties(value) {
+  return IsOptionalBoolean(value) || IsSchema2(value);
+}
+function IsOptionalBigInt(value) {
+  return IsUndefined(value) || IsBigInt(value);
+}
+function IsOptionalNumber(value) {
+  return IsUndefined(value) || IsNumber(value);
+}
+function IsOptionalBoolean(value) {
+  return IsUndefined(value) || IsBoolean(value);
+}
+function IsOptionalString(value) {
+  return IsUndefined(value) || IsString(value);
+}
+function IsOptionalPattern(value) {
+  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
+}
+function IsOptionalFormat(value) {
+  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
+}
+function IsOptionalSchema(value) {
+  return IsUndefined(value) || IsSchema2(value);
+}
+function IsReadonly2(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+}
+function IsOptional2(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
+}
+function IsAny2(value) {
+  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
+}
+function IsArray3(value) {
+  return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+}
+function IsAsyncIterator3(value) {
+  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+}
+function IsBigInt3(value) {
+  return IsKindOf2(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+}
+function IsBoolean3(value) {
+  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+}
+function IsConstructor2(value) {
+  return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+}
+function IsDate3(value) {
+  return IsKindOf2(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+}
+function IsFunction3(value) {
+  return IsKindOf2(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+}
+function IsInteger2(value) {
+  return IsKindOf2(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+function IsProperties(value) {
+  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
+}
+function IsIntersect2(value) {
+  return IsKindOf2(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+}
+function IsIterator3(value) {
+  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+}
+function IsKindOf2(value, kind) {
+  return IsObject(value) && Kind in value && value[Kind] === kind;
+}
+function IsLiteralString(value) {
+  return IsLiteral2(value) && IsString(value.const);
+}
+function IsLiteralNumber(value) {
+  return IsLiteral2(value) && IsNumber(value.const);
+}
+function IsLiteralBoolean(value) {
+  return IsLiteral2(value) && IsBoolean(value.const);
+}
+function IsLiteral2(value) {
+  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue(value.const);
+}
+function IsLiteralValue(value) {
+  return IsBoolean(value) || IsNumber(value) || IsString(value);
+}
+function IsMappedKey2(value) {
+  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
+}
+function IsMappedResult2(value) {
+  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
+}
+function IsNever2(value) {
+  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+}
+function IsNot2(value) {
+  return IsKindOf2(value, "Not") && IsSchema2(value.not);
+}
+function IsNull3(value) {
+  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+}
+function IsNumber3(value) {
+  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+function IsObject3(value) {
+  return IsKindOf2(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+}
+function IsPromise2(value) {
+  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
+}
+function IsRecord2(value) {
+  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
+    const keys = Object.getOwnPropertyNames(schema.patternProperties);
+    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
+  })(value);
+}
+function IsRecursive(value) {
+  return IsObject(value) && Hint in value && value[Hint] === "Recursive";
+}
+function IsRef2(value) {
+  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
+}
+function IsRegExp3(value) {
+  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+}
+function IsString3(value) {
+  return IsKindOf2(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+}
+function IsSymbol3(value) {
+  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+}
+function IsTemplateLiteral2(value) {
+  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+}
+function IsThis2(value) {
+  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
+}
+function IsTransform2(value) {
+  return IsObject(value) && TransformKind in value;
+}
+function IsTuple2(value) {
+  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && // empty
+  (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
+}
+function IsUndefined3(value) {
+  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+}
+function IsUnionLiteral(value) {
+  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+}
+function IsUnion2(value) {
+  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
+}
+function IsUint8Array3(value) {
+  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+}
+function IsUnknown2(value) {
+  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
+}
+function IsUnsafe2(value) {
+  return IsKindOf2(value, "Unsafe");
+}
+function IsVoid2(value) {
+  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+}
+function IsKind2(value) {
+  return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+function IsSchema2(value) {
+  return IsObject(value) && (IsAny2(value) || IsArray3(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber3(value) || IsObject3(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined3(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.mjs
+var ExtendsResolverError = class extends TypeBoxError {
+};
+var ExtendsResult;
+(function(ExtendsResult2) {
+  ExtendsResult2[ExtendsResult2["Union"] = 0] = "Union";
+  ExtendsResult2[ExtendsResult2["True"] = 1] = "True";
+  ExtendsResult2[ExtendsResult2["False"] = 2] = "False";
+})(ExtendsResult || (ExtendsResult = {}));
+function IntoBooleanResult(result) {
+  return result === ExtendsResult.False ? result : ExtendsResult.True;
+}
+function Throw(message) {
+  throw new ExtendsResolverError(message);
+}
+function IsStructuralRight(right) {
+  return type_exports.IsNever(right) || type_exports.IsIntersect(right) || type_exports.IsUnion(right) || type_exports.IsUnknown(right) || type_exports.IsAny(right);
+}
+function StructuralRight(left, right) {
+  return type_exports.IsNever(right) ? FromNeverRight(left, right) : type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsUnknown(right) ? FromUnknownRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : Throw("StructuralRight");
+}
+function FromAnyRight(left, right) {
+  return ExtendsResult.True;
+}
+function FromAny(left, right) {
+  return type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) && right.anyOf.some((schema) => type_exports.IsAny(schema) || type_exports.IsUnknown(schema)) ? ExtendsResult.True : type_exports.IsUnion(right) ? ExtendsResult.Union : type_exports.IsUnknown(right) ? ExtendsResult.True : type_exports.IsAny(right) ? ExtendsResult.True : ExtendsResult.Union;
+}
+function FromArrayRight(left, right) {
+  return type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : type_exports.IsNever(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromArray5(left, right) {
+  return type_exports.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsArray(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
+}
+function FromAsyncIterator2(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsAsyncIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
+}
+function FromBigInt(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsBigInt(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBooleanRight(left, right) {
+  return type_exports.IsLiteralBoolean(left) ? ExtendsResult.True : type_exports.IsBoolean(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBoolean(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsBoolean(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromConstructor2(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsConstructor(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit3(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.returns, right.returns));
+}
+function FromDate(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsDate(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromFunction2(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsFunction(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit3(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.returns, right.returns));
+}
+function FromIntegerRight(left, right) {
+  return type_exports.IsLiteral(left) && value_exports.IsNumber(left.const) ? ExtendsResult.True : type_exports.IsNumber(left) || type_exports.IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromInteger(left, right) {
+  return type_exports.IsInteger(right) || type_exports.IsNumber(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : ExtendsResult.False;
+}
+function FromIntersectRight(left, right) {
+  return right.allOf.every((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIntersect5(left, right) {
+  return left.allOf.some((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIterator2(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
+}
+function FromLiteral2(left, right) {
+  return type_exports.IsLiteral(right) && right.const === left.const ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsString(right) ? FromStringRight(left, right) : type_exports.IsNumber(right) ? FromNumberRight(left, right) : type_exports.IsInteger(right) ? FromIntegerRight(left, right) : type_exports.IsBoolean(right) ? FromBooleanRight(left, right) : ExtendsResult.False;
+}
+function FromNeverRight(left, right) {
+  return ExtendsResult.False;
+}
+function FromNever(left, right) {
+  return ExtendsResult.True;
+}
+function UnwrapTNot(schema) {
+  let [current, depth] = [schema, 0];
+  while (true) {
+    if (!type_exports.IsNot(current))
+      break;
+    current = current.not;
+    depth += 1;
+  }
+  return depth % 2 === 0 ? current : Unknown();
+}
+function FromNot(left, right) {
+  return type_exports.IsNot(left) ? Visit3(UnwrapTNot(left), right) : type_exports.IsNot(right) ? Visit3(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
+}
+function FromNull(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsNull(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumberRight(left, right) {
+  return type_exports.IsLiteralNumber(left) ? ExtendsResult.True : type_exports.IsNumber(left) || type_exports.IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumber(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsInteger(right) || type_exports.IsNumber(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function IsObjectPropertyCount(schema, count) {
+  return Object.getOwnPropertyNames(schema.properties).length === count;
+}
+function IsObjectStringLike(schema) {
+  return IsObjectArrayLike(schema);
+}
+function IsObjectSymbolLike(schema) {
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && type_exports.IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (type_exports.IsString(schema.properties.description.anyOf[0]) && type_exports.IsUndefined(schema.properties.description.anyOf[1]) || type_exports.IsString(schema.properties.description.anyOf[1]) && type_exports.IsUndefined(schema.properties.description.anyOf[0]));
+}
+function IsObjectNumberLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBooleanLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBigIntLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectDateLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectUint8ArrayLike(schema) {
+  return IsObjectArrayLike(schema);
+}
+function IsObjectFunctionLike(schema) {
+  const length = Number2();
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectConstructorLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectArrayLike(schema) {
+  const length = Number2();
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectPromiseLike(schema) {
+  const then = Function2([Any()], Any());
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit3(schema.properties["then"], then)) === ExtendsResult.True;
+}
+function Property(left, right) {
+  return Visit3(left, right) === ExtendsResult.False ? ExtendsResult.False : type_exports.IsOptional(left) && !type_exports.IsOptional(right) ? ExtendsResult.False : ExtendsResult.True;
+}
+function FromObjectRight(left, right) {
+  return type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : type_exports.IsNever(left) || type_exports.IsLiteralString(left) && IsObjectStringLike(right) || type_exports.IsLiteralNumber(left) && IsObjectNumberLike(right) || type_exports.IsLiteralBoolean(left) && IsObjectBooleanLike(right) || type_exports.IsSymbol(left) && IsObjectSymbolLike(right) || type_exports.IsBigInt(left) && IsObjectBigIntLike(right) || type_exports.IsString(left) && IsObjectStringLike(right) || type_exports.IsSymbol(left) && IsObjectSymbolLike(right) || type_exports.IsNumber(left) && IsObjectNumberLike(right) || type_exports.IsInteger(left) && IsObjectNumberLike(right) || type_exports.IsBoolean(left) && IsObjectBooleanLike(right) || type_exports.IsUint8Array(left) && IsObjectUint8ArrayLike(right) || type_exports.IsDate(left) && IsObjectDateLike(right) || type_exports.IsConstructor(left) && IsObjectConstructorLike(right) || type_exports.IsFunction(left) && IsObjectFunctionLike(right) ? ExtendsResult.True : type_exports.IsRecord(left) && type_exports.IsString(RecordKey(left)) ? (() => {
+    return right[Hint] === "Record" ? ExtendsResult.True : ExtendsResult.False;
+  })() : type_exports.IsRecord(left) && type_exports.IsNumber(RecordKey(left)) ? (() => {
+    return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
+  })() : ExtendsResult.False;
+}
+function FromObject2(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : !type_exports.IsObject(right) ? ExtendsResult.False : (() => {
+    for (const key of Object.getOwnPropertyNames(right.properties)) {
+      if (!(key in left.properties) && !type_exports.IsOptional(right.properties[key])) {
+        return ExtendsResult.False;
+      }
+      if (type_exports.IsOptional(right.properties[key])) {
+        return ExtendsResult.True;
+      }
+      if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
+        return ExtendsResult.False;
+      }
+    }
+    return ExtendsResult.True;
+  })();
+}
+function FromPromise3(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True : !type_exports.IsPromise(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.item, right.item));
+}
+function RecordKey(schema) {
+  return PatternNumberExact in schema.patternProperties ? Number2() : PatternStringExact in schema.patternProperties ? String() : Throw("Unknown record key pattern");
+}
+function RecordValue(schema) {
+  return PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] : PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
+}
+function FromRecordRight(left, right) {
+  const [Key, Value] = [RecordKey(right), RecordValue(right)];
+  return type_exports.IsLiteralString(left) && type_exports.IsNumber(Key) && IntoBooleanResult(Visit3(left, Value)) === ExtendsResult.True ? ExtendsResult.True : type_exports.IsUint8Array(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsString(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsArray(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsObject(left) ? (() => {
+    for (const key of Object.getOwnPropertyNames(left.properties)) {
+      if (Property(Value, left.properties[key]) === ExtendsResult.False) {
+        return ExtendsResult.False;
+      }
+    }
+    return ExtendsResult.True;
+  })() : ExtendsResult.False;
+}
+function FromRecord(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsRecord(right) ? ExtendsResult.False : Visit3(RecordValue(left), RecordValue(right));
+}
+function FromRegExp(left, right) {
+  const L = type_exports.IsRegExp(left) ? String() : left;
+  const R = type_exports.IsRegExp(right) ? String() : right;
+  return Visit3(L, R);
+}
+function FromStringRight(left, right) {
+  return type_exports.IsLiteral(left) && value_exports.IsString(left.const) ? ExtendsResult.True : type_exports.IsString(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromString(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsString(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromSymbol(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsSymbol(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromTemplateLiteral2(left, right) {
+  return type_exports.IsTemplateLiteral(left) ? Visit3(TemplateLiteralToUnion(left), right) : type_exports.IsTemplateLiteral(right) ? Visit3(left, TemplateLiteralToUnion(right)) : Throw("Invalid fallthrough for TemplateLiteral");
+}
+function IsArrayOfTuple(left, right) {
+  return type_exports.IsArray(right) && left.items !== void 0 && left.items.every((schema) => Visit3(schema, right.items) === ExtendsResult.True);
+}
+function FromTupleRight(left, right) {
+  return type_exports.IsNever(left) ? ExtendsResult.True : type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : ExtendsResult.False;
+}
+function FromTuple4(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : type_exports.IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True : !type_exports.IsTuple(right) ? ExtendsResult.False : value_exports.IsUndefined(left.items) && !value_exports.IsUndefined(right.items) || !value_exports.IsUndefined(left.items) && value_exports.IsUndefined(right.items) ? ExtendsResult.False : value_exports.IsUndefined(left.items) && !value_exports.IsUndefined(right.items) ? ExtendsResult.True : left.items.every((schema, index) => Visit3(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUint8Array(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsUint8Array(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUndefined(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsVoid(right) ? FromVoidRight(left, right) : type_exports.IsUndefined(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnionRight(left, right) {
+  return right.anyOf.some((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnion7(left, right) {
+  return left.anyOf.every((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnknownRight(left, right) {
+  return ExtendsResult.True;
+}
+function FromUnknown(left, right) {
+  return type_exports.IsNever(right) ? FromNeverRight(left, right) : type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : type_exports.IsString(right) ? FromStringRight(left, right) : type_exports.IsNumber(right) ? FromNumberRight(left, right) : type_exports.IsInteger(right) ? FromIntegerRight(left, right) : type_exports.IsBoolean(right) ? FromBooleanRight(left, right) : type_exports.IsArray(right) ? FromArrayRight(left, right) : type_exports.IsTuple(right) ? FromTupleRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsUnknown(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoidRight(left, right) {
+  return type_exports.IsUndefined(left) ? ExtendsResult.True : type_exports.IsUndefined(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoid(left, right) {
+  return type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsUnknown(right) ? FromUnknownRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsVoid(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function Visit3(left, right) {
+  return (
+    // resolvable
+    type_exports.IsTemplateLiteral(left) || type_exports.IsTemplateLiteral(right) ? FromTemplateLiteral2(left, right) : type_exports.IsRegExp(left) || type_exports.IsRegExp(right) ? FromRegExp(left, right) : type_exports.IsNot(left) || type_exports.IsNot(right) ? FromNot(left, right) : (
+      // standard
+      type_exports.IsAny(left) ? FromAny(left, right) : type_exports.IsArray(left) ? FromArray5(left, right) : type_exports.IsBigInt(left) ? FromBigInt(left, right) : type_exports.IsBoolean(left) ? FromBoolean(left, right) : type_exports.IsAsyncIterator(left) ? FromAsyncIterator2(left, right) : type_exports.IsConstructor(left) ? FromConstructor2(left, right) : type_exports.IsDate(left) ? FromDate(left, right) : type_exports.IsFunction(left) ? FromFunction2(left, right) : type_exports.IsInteger(left) ? FromInteger(left, right) : type_exports.IsIntersect(left) ? FromIntersect5(left, right) : type_exports.IsIterator(left) ? FromIterator2(left, right) : type_exports.IsLiteral(left) ? FromLiteral2(left, right) : type_exports.IsNever(left) ? FromNever(left, right) : type_exports.IsNull(left) ? FromNull(left, right) : type_exports.IsNumber(left) ? FromNumber(left, right) : type_exports.IsObject(left) ? FromObject2(left, right) : type_exports.IsRecord(left) ? FromRecord(left, right) : type_exports.IsString(left) ? FromString(left, right) : type_exports.IsSymbol(left) ? FromSymbol(left, right) : type_exports.IsTuple(left) ? FromTuple4(left, right) : type_exports.IsPromise(left) ? FromPromise3(left, right) : type_exports.IsUint8Array(left) ? FromUint8Array(left, right) : type_exports.IsUndefined(left) ? FromUndefined(left, right) : type_exports.IsUnion(left) ? FromUnion7(left, right) : type_exports.IsUnknown(left) ? FromUnknown(left, right) : type_exports.IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`)
+    )
+  );
+}
+function ExtendsCheck(left, right) {
+  return Visit3(left, right);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.mjs
+function FromProperties9(P, Right, True, False, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Extends(P[K2], Right, True, False, options);
+  return Acc;
+}
+function FromMappedResult6(Left, Right, True, False, options) {
+  return FromProperties9(Left.properties, Right, True, False, options);
+}
+function ExtendsFromMappedResult(Left, Right, True, False, options) {
+  const P = FromMappedResult6(Left, Right, True, False, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extends/extends.mjs
+function ExtendsResolve(left, right, trueType, falseType) {
+  const R = ExtendsCheck(left, right);
+  return R === ExtendsResult.Union ? Union([trueType, falseType]) : R === ExtendsResult.True ? trueType : falseType;
+}
+function Extends(L, R, T, F, options = {}) {
+  return IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) : IsMappedKey(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) : CloneType(ExtendsResolve(L, R, T, F), options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.mjs
+function FromPropertyKey(K, U, L, R, options) {
+  return {
+    [K]: Extends(Literal(K), U, L, R, options)
+  };
+}
+function FromPropertyKeys(K, U, L, R, options) {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) };
+  }, {});
+}
+function FromMappedKey2(K, U, L, R, options) {
+  return FromPropertyKeys(K.keys, U, L, R, options);
+}
+function ExtendsFromMappedKey(T, U, L, R, options) {
+  const P = FromMappedKey2(T, U, L, R, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.mjs
+function ExcludeFromTemplateLiteral(L, R) {
+  return Exclude(TemplateLiteralToUnion(L), R);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.mjs
+function ExcludeRest(L, R) {
+  const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+  return excluded.length === 1 ? excluded[0] : Union(excluded);
+}
+function Exclude(L, R, options = {}) {
+  if (IsTemplateLiteral(L))
+    return CloneType(ExcludeFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    return CloneType(ExcludeFromMappedResult(L, R), options);
+  return CloneType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.mjs
+function FromProperties10(P, U) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Exclude(P[K2], U);
+  return Acc;
+}
+function FromMappedResult7(R, T) {
+  return FromProperties10(R.properties, T);
+}
+function ExcludeFromMappedResult(R, T) {
+  const P = FromMappedResult7(R, T);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs
+function ExtractFromTemplateLiteral(L, R) {
+  return Extract(TemplateLiteralToUnion(L), R);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs
+function ExtractRest(L, R) {
+  const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+  return extracted.length === 1 ? extracted[0] : Union(extracted);
+}
+function Extract(L, R, options = {}) {
+  if (IsTemplateLiteral(L))
+    return CloneType(ExtractFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    return CloneType(ExtractFromMappedResult(L, R), options);
+  return CloneType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs
+function FromProperties11(P, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Extract(P[K2], T);
+  return Acc;
+}
+function FromMappedResult8(R, T) {
+  return FromProperties11(R.properties, T);
+}
+function ExtractFromMappedResult(R, T) {
+  const P = FromMappedResult8(R, T);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
+function InstanceType(schema, options = {}) {
+  return CloneType(schema.returns, options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
+function Integer(options = {}) {
+  return {
+    ...options,
+    [Kind]: "Integer",
+    type: "integer"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.mjs
+function MappedIntrinsicPropertyKey(K, M, options) {
+  return {
+    [K]: Intrinsic(Literal(K), M, options)
+  };
+}
+function MappedIntrinsicPropertyKeys(K, M, options) {
+  return K.reduce((Acc, L) => {
+    return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
+  }, {});
+}
+function MappedIntrinsicProperties(T, M, options) {
+  return MappedIntrinsicPropertyKeys(T["keys"], M, options);
+}
+function IntrinsicFromMappedKey(T, M, options) {
+  const P = MappedIntrinsicProperties(T, M, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.mjs
+function ApplyUncapitalize(value) {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)];
+  return [first.toLowerCase(), rest].join("");
+}
+function ApplyCapitalize(value) {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)];
+  return [first.toUpperCase(), rest].join("");
+}
+function ApplyUppercase(value) {
+  return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+  return value.toLowerCase();
+}
+function FromTemplateLiteral3(schema, mode, options) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  const finite = IsTemplateLiteralExpressionFinite(expression);
+  if (!finite)
+    return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
+  const strings = [...TemplateLiteralExpressionGenerate(expression)];
+  const literals = strings.map((value) => Literal(value));
+  const mapped = FromRest6(literals, mode);
+  const union = Union(mapped);
+  return TemplateLiteral([union], options);
+}
+function FromLiteralValue(value, mode) {
+  return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
+}
+function FromRest6(T, M) {
+  return T.map((L) => Intrinsic(L, M));
+}
+function Intrinsic(schema, mode, options = {}) {
+  return (
+    // Intrinsic-Mapped-Inference
+    IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : (
+      // Standard-Inference
+      IsTemplateLiteral(schema) ? FromTemplateLiteral3(schema, mode, schema) : IsUnion(schema) ? Union(FromRest6(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : schema
+    )
+  );
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.mjs
+function Capitalize(T, options = {}) {
+  return Intrinsic(T, "Capitalize", options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.mjs
+function Lowercase(T, options = {}) {
+  return Intrinsic(T, "Lowercase", options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.mjs
+function Uncapitalize(T, options = {}) {
+  return Intrinsic(T, "Uncapitalize", options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.mjs
+function Uppercase(T, options = {}) {
+  return Intrinsic(T, "Uppercase", options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/not/not.mjs
+function Not(schema, options) {
+  return {
+    ...options,
+    [Kind]: "Not",
+    not: CloneType(schema)
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.mjs
+function FromProperties12(P, K, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Omit(P[K2], K, options);
+  return Acc;
+}
+function FromMappedResult9(R, K, options) {
+  return FromProperties12(R.properties, K, options);
+}
+function OmitFromMappedResult(R, K, options) {
+  const P = FromMappedResult9(R, K, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/omit/omit.mjs
+function FromIntersect6(T, K) {
+  return T.map((T2) => OmitResolve(T2, K));
+}
+function FromUnion8(T, K) {
+  return T.map((T2) => OmitResolve(T2, K));
+}
+function FromProperty2(T, K) {
+  const { [K]: _, ...R } = T;
+  return R;
+}
+function FromProperties13(T, K) {
+  return K.reduce((T2, K2) => FromProperty2(T2, K2), T);
+}
+function OmitResolve(T, K) {
+  return IsIntersect(T) ? Intersect(FromIntersect6(T.allOf, K)) : IsUnion(T) ? Union(FromUnion8(T.anyOf, K)) : IsObject2(T) ? Object2(FromProperties13(T.properties, K)) : Object2({});
+}
+function Omit(T, K, options = {}) {
+  if (IsMappedKey(K))
+    return OmitFromMappedKey(T, K, options);
+  if (IsMappedResult(T))
+    return OmitFromMappedResult(T, K, options);
+  const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
+  const D = Discard(T, [TransformKind, "$id", "required"]);
+  const R = CloneType(OmitResolve(T, I), options);
+  return { ...D, ...R };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.mjs
+function FromPropertyKey2(T, K, options) {
+  return {
+    [K]: Omit(T, [K], options)
+  };
+}
+function FromPropertyKeys2(T, K, options) {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey2(T, LK, options) };
+  }, {});
+}
+function FromMappedKey3(T, K, options) {
+  return FromPropertyKeys2(T, K.keys, options);
+}
+function OmitFromMappedKey(T, K, options) {
+  const P = FromMappedKey3(T, K, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
+function Parameters(schema, options = {}) {
+  return Tuple(CloneRest(schema.parameters), { ...options });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/partial/partial.mjs
+function FromRest7(T) {
+  return T.map((L) => PartialResolve(L));
+}
+function FromProperties14(T) {
+  const Acc = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(T))
+    Acc[K] = Optional(T[K]);
+  return Acc;
+}
+function PartialResolve(T) {
+  return IsIntersect(T) ? Intersect(FromRest7(T.allOf)) : IsUnion(T) ? Union(FromRest7(T.anyOf)) : IsObject2(T) ? Object2(FromProperties14(T.properties)) : Object2({});
+}
+function Partial(T, options = {}) {
+  if (IsMappedResult(T))
+    return PartialFromMappedResult(T, options);
+  const D = Discard(T, [TransformKind, "$id", "required"]);
+  const R = CloneType(PartialResolve(T), options);
+  return { ...D, ...R };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
+function FromProperties15(K, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Partial(K[K2], options);
+  return Acc;
+}
+function FromMappedResult10(R, options) {
+  return FromProperties15(R.properties, options);
+}
+function PartialFromMappedResult(R, options) {
+  const P = FromMappedResult10(R, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
+function FromProperties16(P, K, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Pick(P[K2], K, options);
+  return Acc;
+}
+function FromMappedResult11(R, K, options) {
+  return FromProperties16(R.properties, K, options);
+}
+function PickFromMappedResult(R, K, options) {
+  const P = FromMappedResult11(R, K, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs
+function FromIntersect7(T, K) {
+  return T.map((T2) => PickResolve(T2, K));
+}
+function FromUnion9(T, K) {
+  return T.map((T2) => PickResolve(T2, K));
+}
+function FromProperties17(T, K) {
+  const Acc = {};
+  for (const K2 of K)
+    if (K2 in T)
+      Acc[K2] = T[K2];
+  return Acc;
+}
+function PickResolve(T, K) {
+  return IsIntersect(T) ? Intersect(FromIntersect7(T.allOf, K)) : IsUnion(T) ? Union(FromUnion9(T.anyOf, K)) : IsObject2(T) ? Object2(FromProperties17(T.properties, K)) : Object2({});
+}
+function Pick(T, K, options = {}) {
+  if (IsMappedKey(K))
+    return PickFromMappedKey(T, K, options);
+  if (IsMappedResult(T))
+    return PickFromMappedResult(T, K, options);
+  const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
+  const D = Discard(T, [TransformKind, "$id", "required"]);
+  const R = CloneType(PickResolve(T, I), options);
+  return { ...D, ...R };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.mjs
+function FromPropertyKey3(T, K, options) {
+  return {
+    [K]: Pick(T, [K], options)
+  };
+}
+function FromPropertyKeys3(T, K, options) {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey3(T, LK, options) };
+  }, {});
+}
+function FromMappedKey4(T, K, options) {
+  return FromPropertyKeys3(T, K.keys, options);
+}
+function PickFromMappedKey(T, K, options) {
+  const P = FromMappedKey4(T, K, options);
+  return MappedResult(P);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
+function ReadonlyOptional(schema) {
+  return Readonly(Optional(schema));
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
+function RecordCreateFromPattern(pattern, T, options) {
+  return {
+    ...options,
+    [Kind]: "Record",
+    type: "object",
+    patternProperties: { [pattern]: CloneType(T) }
+  };
+}
+function RecordCreateFromKeys(K, T, options) {
+  const Acc = {};
+  for (const K2 of K)
+    Acc[K2] = CloneType(T);
+  return Object2(Acc, { ...options, [Hint]: "Record" });
+}
+function FromTemplateLiteralKey(K, T, options) {
+  return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
+}
+function FromUnionKey(K, T, options) {
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options);
+}
+function FromLiteralKey(K, T, options) {
+  return RecordCreateFromKeys([K.toString()], T, options);
+}
+function FromRegExpKey(K, T, options) {
+  return RecordCreateFromPattern(K.source, T, options);
+}
+function FromStringKey(K, T, options) {
+  const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern;
+  return RecordCreateFromPattern(pattern, T, options);
+}
+function FromIntegerKey(_, T, options) {
+  return RecordCreateFromPattern(PatternNumberExact, T, options);
+}
+function FromNumberKey(_, T, options) {
+  return RecordCreateFromPattern(PatternNumberExact, T, options);
+}
+function Record(K, T, options = {}) {
+  return IsUnion(K) ? FromUnionKey(K.anyOf, T, options) : IsTemplateLiteral(K) ? FromTemplateLiteralKey(K, T, options) : IsLiteral(K) ? FromLiteralKey(K.const, T, options) : IsInteger(K) ? FromIntegerKey(K, T, options) : IsNumber2(K) ? FromNumberKey(K, T, options) : IsRegExp2(K) ? FromRegExpKey(K, T, options) : IsString2(K) ? FromStringKey(K, T, options) : Never(options);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
+var Ordinal = 0;
+function Recursive(callback, options = {}) {
+  if (IsUndefined(options.$id))
+    options.$id = `T${Ordinal++}`;
+  const thisType = callback({ [Kind]: "This", $ref: `${options.$id}` });
+  thisType.$id = options.$id;
+  return CloneType({ ...options, [Hint]: "Recursive", ...thisType });
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/ref/ref.mjs
+function Ref(unresolved, options = {}) {
+  if (IsString(unresolved))
+    return { ...options, [Kind]: "Ref", $ref: unresolved };
+  if (IsUndefined(unresolved.$id))
+    throw new Error("Reference target type must specify an $id");
+  return {
+    ...options,
+    [Kind]: "Ref",
+    $ref: unresolved.$id
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
+function RegExp2(unresolved, options = {}) {
+  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+  return { ...options, [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/registry/format.mjs
+var format_exports = {};
+__export(format_exports, {
+  Clear: () => Clear,
+  Delete: () => Delete,
+  Entries: () => Entries,
+  Get: () => Get,
+  Has: () => Has,
+  Set: () => Set2
+});
+var map = /* @__PURE__ */ new Map();
+function Entries() {
+  return new Map(map);
+}
+function Clear() {
+  return map.clear();
+}
+function Delete(format) {
+  return map.delete(format);
+}
+function Has(format) {
+  return map.has(format);
+}
+function Set2(format, func) {
+  map.set(format, func);
+}
+function Get(format) {
+  return map.get(format);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/registry/type.mjs
+var type_exports2 = {};
+__export(type_exports2, {
+  Clear: () => Clear2,
+  Delete: () => Delete2,
+  Entries: () => Entries2,
+  Get: () => Get2,
+  Has: () => Has2,
+  Set: () => Set3
+});
+var map2 = /* @__PURE__ */ new Map();
+function Entries2() {
+  return new Map(map2);
+}
+function Clear2() {
+  return map2.clear();
+}
+function Delete2(kind) {
+  return map2.delete(kind);
+}
+function Has2(kind) {
+  return map2.has(kind);
+}
+function Set3(kind, func) {
+  map2.set(kind, func);
+}
+function Get2(kind) {
+  return map2.get(kind);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/required/required.mjs
+function FromRest8(T) {
+  return T.map((L) => RequiredResolve(L));
+}
+function FromProperties18(T) {
+  const Acc = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(T))
+    Acc[K] = Discard(T[K], [OptionalKind]);
+  return Acc;
 }
-function TitleLabel({ children }) {
-  return /* @__PURE__ */ import_react4.default.createElement("span", { style: { display: "flex", alignItems: "center", gap: "4px" } }, children);
+function RequiredResolve(T) {
+  return IsIntersect(T) ? Intersect(FromRest8(T.allOf)) : IsUnion(T) ? Union(FromRest8(T.anyOf)) : IsObject2(T) ? Object2(FromProperties18(T.properties)) : Object2({});
+}
+function Required(T, options = {}) {
+  if (IsMappedResult(T)) {
+    return RequiredFromMappedResult(T, options);
+  } else {
+    const D = Discard(T, [TransformKind, "$id", "required"]);
+    const R = CloneType(RequiredResolve(T), options);
+    return { ...D, ...R };
+  }
 }
 
-// src/inspector/useStateInspector.tsx
-function createShadowRootElement() {
-  const host = document.createElement("div");
-  host.id = "noya-multiplayer-react-inspector-host";
-  const shadowRoot = host.attachShadow({ mode: "open" });
-  const container = document.createElement("div");
-  shadowRoot.appendChild(container);
-  return { host, container };
+// ../../node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.mjs
+function FromProperties19(P, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Required(P[K2], options);
+  return Acc;
 }
-function useStateInspector({
-  noyaManager,
-  disabled = false,
-  colorScheme,
-  anchor
-}) {
-  const [root, setRoot] = import_react5.default.useState(null);
-  (0, import_react5.useLayoutEffect)(() => {
-    if (disabled) return;
-    const { host, container } = createShadowRootElement();
-    const root2 = (0, import_client.createRoot)(container);
-    document.body.appendChild(host);
-    setRoot(root2);
-    return () => {
-      document.body.removeChild(host);
-    };
-  }, [disabled]);
-  (0, import_react5.useLayoutEffect)(() => {
-    if (!root) return;
-    root.render(
-      /* @__PURE__ */ import_react5.default.createElement(
-        StateInspector,
-        {
-          colorScheme,
-          anchor,
-          noyaManager
-        }
-      )
-    );
-  }, [noyaManager, anchor, colorScheme, root]);
+function FromMappedResult12(R, options) {
+  return FromProperties19(R.properties, options);
+}
+function RequiredFromMappedResult(R, options) {
+  const P = FromMappedResult12(R, options);
+  return MappedResult(P);
 }
 
-// src/hooks.ts
-function useSyncStateManager(stateManager, path) {
-  const getSnapshot = (0, import_react6.useCallback)(
-    () => typeof path === "string" ? stateManager.getState(path) : stateManager.getState(),
-    [stateManager, path]
-  );
-  return (0, import_react6.useSyncExternalStore)(
-    stateManager.addListener,
-    getSnapshot,
-    getSnapshot
-  );
+// ../../node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
+function RestResolve(T) {
+  return IsIntersect(T) ? CloneRest(T.allOf) : IsUnion(T) ? CloneRest(T.anyOf) : IsTuple(T) ? CloneRest(T.items ?? []) : [];
 }
-function useManagedState(createInitialState, options) {
-  const [stateManager] = (0, import_react6.useState)(
-    () => new import_state_manager.StateManager(createInitialState(), options)
-  );
-  const state = useSyncStateManager(stateManager);
-  const setState = (0, import_react6.useCallback)(
-    (...args) => {
-      const [metadata, action] = args.length === 1 ? [void 0, args[0]] : args;
-      if (metadata === void 0) {
-        const performActionNoMetadata = stateManager.performAction;
-        if (action instanceof Function) {
-          performActionNoMetadata({
-            run: action,
-            undo: () => state
-          });
-        } else {
-          performActionNoMetadata({
-            run: () => action,
-            undo: () => state
-          });
-        }
-      } else {
-        const performActionWithMetadata = stateManager.performAction;
-        if (action instanceof Function) {
-          performActionWithMetadata(metadata, {
-            run: action,
-            undo: () => state
-          });
-        } else {
-          performActionWithMetadata(metadata, {
-            run: () => action,
-            undo: () => state
-          });
-        }
-      }
-    },
-    [state, stateManager]
-  );
-  return [state, setState, stateManager];
+function Rest(T) {
+  return CloneRest(RestResolve(T));
 }
-function useManagedHistory(stateManager) {
-  return (0, import_react6.useSyncExternalStore)(
-    stateManager.historyEmittor.addListener,
-    stateManager.getHistorySnapshot,
-    stateManager.getHistorySnapshot
-  );
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
+function ReturnType(schema, options = {}) {
+  return CloneType(schema.returns, options);
 }
-var defaultStubSync = (0, import_state_manager.stubSync)();
-function useMultiplayerState(initialState, options) {
-  const {
-    sync = defaultStubSync,
-    inspector,
-    ...rest
-  } = options ?? {};
-  const [noyaManager] = (0, import_react6.useState)(
-    () => new import_state_manager.NoyaManager(initialState, rest)
-  );
-  const state = useObservable(
-    noyaManager.multiplayerStateManager.optimisticState$
-  );
-  const assets = useObservable(noyaManager.assetManager.assets$);
-  const extras = (0, import_react6.useMemo)(() => {
-    return {
-      noyaManager,
-      taskManager: noyaManager.taskManager,
-      connectionEventManager: noyaManager.connectionEventManager,
-      connectedUsersManager: noyaManager.connectedUsersManager,
-      ephemeralUserDataManager: noyaManager.ephemeralUserDataManager,
-      multiplayerStateManager: noyaManager.multiplayerStateManager,
-      assetManager: noyaManager.assetManager,
-      aiManager: noyaManager.aiManager,
-      rpcManager: noyaManager.rpcManager,
-      workflowManager: noyaManager.workflowManager,
-      secretManager: noyaManager.secretManager,
-      menuItemsManager: noyaManager.menuManager,
-      createAsset: noyaManager.assetManager.create,
-      deleteAsset: noyaManager.assetManager.delete,
-      assets
-    };
-  }, [noyaManager, assets]);
-  const syncRef = (0, import_react6.useRef)(sync);
-  (0, import_react6.useEffect)(() => {
-    if (syncRef.current) {
-      return syncRef.current({ noyaManager });
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/strict/strict.mjs
+function Strict(schema) {
+  return JSON.parse(JSON.stringify(schema));
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
+var TransformDecodeBuilder = class {
+  schema;
+  constructor(schema) {
+    this.schema = schema;
+  }
+  Decode(decode) {
+    return new TransformEncodeBuilder(this.schema, decode);
+  }
+};
+var TransformEncodeBuilder = class {
+  schema;
+  decode;
+  constructor(schema, decode) {
+    this.schema = schema;
+    this.decode = decode;
+  }
+  EncodeTransform(encode, schema) {
+    const Encode = (value) => schema[TransformKind].Encode(encode(value));
+    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+    const Codec = { Encode, Decode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  EncodeSchema(encode, schema) {
+    const Codec = { Decode: this.decode, Encode: encode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  Encode(encode) {
+    const schema = CloneType(this.schema);
+    return IsTransform(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema);
+  }
+};
+function Transform(schema) {
+  return new TransformDecodeBuilder(schema);
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
+function Unsafe(options = {}) {
+  return {
+    ...options,
+    [Kind]: options[Kind] ?? "Unsafe"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
+var type_exports3 = {};
+__export(type_exports3, {
+  Any: () => Any,
+  Array: () => Array2,
+  AsyncIterator: () => AsyncIterator,
+  Awaited: () => Awaited,
+  BigInt: () => BigInt2,
+  Boolean: () => Boolean,
+  Capitalize: () => Capitalize,
+  Composite: () => Composite,
+  Const: () => Const,
+  Constructor: () => Constructor,
+  ConstructorParameters: () => ConstructorParameters,
+  Date: () => Date2,
+  Deref: () => Deref,
+  Enum: () => Enum,
+  Exclude: () => Exclude,
+  Extends: () => Extends,
+  Extract: () => Extract,
+  Function: () => Function2,
+  Index: () => Index,
+  InstanceType: () => InstanceType,
+  Integer: () => Integer,
+  Intersect: () => Intersect,
+  Iterator: () => Iterator,
+  KeyOf: () => KeyOf,
+  Literal: () => Literal,
+  Lowercase: () => Lowercase,
+  Mapped: () => Mapped,
+  Never: () => Never,
+  Not: () => Not,
+  Null: () => Null,
+  Number: () => Number2,
+  Object: () => Object2,
+  Omit: () => Omit,
+  Optional: () => Optional,
+  Parameters: () => Parameters,
+  Partial: () => Partial,
+  Pick: () => Pick,
+  Promise: () => Promise2,
+  Readonly: () => Readonly,
+  ReadonlyOptional: () => ReadonlyOptional,
+  Record: () => Record,
+  Recursive: () => Recursive,
+  Ref: () => Ref,
+  RegExp: () => RegExp2,
+  Required: () => Required,
+  Rest: () => Rest,
+  ReturnType: () => ReturnType,
+  Strict: () => Strict,
+  String: () => String,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral,
+  Transform: () => Transform,
+  Tuple: () => Tuple,
+  Uint8Array: () => Uint8Array2,
+  Uncapitalize: () => Uncapitalize,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  Void: () => Void
+});
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
+function Void(options = {}) {
+  return {
+    ...options,
+    [Kind]: "Void",
+    type: "void"
+  };
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
+var Type = type_exports3;
+
+// ../noya-schemas/src/jsonSchema.ts
+var jsonSchema = Type.Recursive(
+  (This) => Type.Union(
+    [
+      Type.Object({
+        type: Type.Literal("string"),
+        default: Type.Optional(Type.String()),
+        _kind: Type.Literal("String")
+      }),
+      Type.Object({
+        type: Type.Literal("number"),
+        default: Type.Optional(Type.Number()),
+        minimum: Type.Optional(Type.Number()),
+        maximum: Type.Optional(Type.Number()),
+        _kind: Type.Literal("Number")
+      }),
+      Type.Object({
+        type: Type.Literal("boolean"),
+        default: Type.Optional(Type.Boolean()),
+        _kind: Type.Literal("Boolean")
+      }),
+      Type.Object({
+        type: Type.Literal("null"),
+        _kind: Type.Literal("Null")
+      }),
+      Type.Object({
+        type: Type.Literal("array"),
+        items: This,
+        // default: Type.Optional(Type.Array(Type.Any())),
+        // minItems: Type.Optional(Type.Number()),
+        // maxItems: Type.Optional(Type.Number()),
+        _kind: Type.Literal("Array")
+      }),
+      Type.Object({
+        type: Type.Literal("object"),
+        properties: Type.Record(Type.String(), This),
+        required: Type.Optional(Type.Array(Type.String())),
+        // default: Type.Optional(Type.Record(Type.String(), Type.Any())),
+        _kind: Type.Literal("Object")
+      })
+    ],
+    {
+      discriminator: "type"
     }
-  }, [noyaManager]);
-  useErrorOverlay(noyaManager);
-  useStateInspector({
-    noyaManager,
-    disabled: !inspector,
-    ...typeof inspector === "object" && inspector
-  });
-  return [state, noyaManager.multiplayerStateManager.setState, extras];
+  ),
+  {
+    $id: "jsonSchema"
+  }
+);
+
+// ../noya-schemas/src/input.ts
+function Nullable(type) {
+  return Type.Union([type, Type.Null()]);
 }
-function useErrorOverlay(noyaManager) {
-  const unrecoverableError = useObservable(noyaManager.unrecoverableError);
-  (0, import_react6.useEffect)(() => {
-    if (!unrecoverableError) return;
-    const el = document.createElement("div");
-    el.id = "noya-multiplayer-react-error-overlay";
-    document.body.appendChild(el);
-    const root = (0, import_client2.createRoot)(el);
-    root.render((0, import_react6.createElement)(ErrorOverlay, { error: unrecoverableError }));
-    return () => {
-      root.unmount();
-      el.remove();
-    };
+var inputSchemaBase = {
+  id: Type.String({ format: "uuid", default: "" }),
+  name: Type.String(),
+  description: Nullable(Type.String()),
+  required: Type.Boolean({ default: false })
+};
+var fileInputSchema = Type.Object({
+  ...inputSchemaBase,
+  kind: Type.Literal("file"),
+  toolId: Nullable(Type.String())
+});
+var dataInputSchema = Type.Object({
+  ...inputSchemaBase,
+  kind: Type.Literal("data"),
+  schema: Nullable(jsonSchema)
+});
+var inputSchema = Type.Union([fileInputSchema, dataInputSchema], {
+  discriminator: "kind"
+});
+var outputTransformSchemaBase = {
+  id: Type.String({ format: "uuid", default: "" }),
+  order: Type.Number()
+};
+var scriptOutputTransformSchema = Type.Object({
+  ...outputTransformSchemaBase,
+  kind: Type.Literal("script"),
+  location: Type.Union([Type.Literal("state"), Type.Literal("url")]),
+  value: Type.String()
+});
+var jsonPointerOutputTransformSchema = Type.Object({
+  ...outputTransformSchemaBase,
+  kind: Type.Literal("jsonPointer"),
+  value: Type.String()
+});
+var outputTransformSchema = Type.Union(
+  [scriptOutputTransformSchema, jsonPointerOutputTransformSchema],
+  { discriminator: "kind" }
+);
+
+// ../../node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
+function IsObject4(value) {
+  return value !== null && typeof value === "object";
+}
+function IsArray4(value) {
+  return Array.isArray(value) && !ArrayBuffer.isView(value);
+}
+function IsUndefined4(value) {
+  return value === void 0;
+}
+function IsNumber4(value) {
+  return typeof value === "number";
+}
+
+// ../../node_modules/@sinclair/typebox/build/esm/system/policy.mjs
+var TypeSystemPolicy;
+(function(TypeSystemPolicy2) {
+  TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
+  TypeSystemPolicy2.AllowArrayObject = false;
+  TypeSystemPolicy2.AllowNaN = false;
+  TypeSystemPolicy2.AllowNullVoid = false;
+  function IsExactOptionalProperty(value, key) {
+    return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
+  }
+  TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
+  function IsObjectLike(value) {
+    const isObject = IsObject4(value);
+    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray4(value);
+  }
+  TypeSystemPolicy2.IsObjectLike = IsObjectLike;
+  function IsRecordLike(value) {
+    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+  }
+  TypeSystemPolicy2.IsRecordLike = IsRecordLike;
+  function IsNumberLike(value) {
+    return TypeSystemPolicy2.AllowNaN ? IsNumber4(value) : Number.isFinite(value);
+  }
+  TypeSystemPolicy2.IsNumberLike = IsNumberLike;
+  function IsVoidLike(value) {
+    const isUndefined = IsUndefined4(value);
+    return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
+  }
+  TypeSystemPolicy2.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));
+
+// ../../node_modules/@sinclair/typebox/build/esm/system/system.mjs
+var TypeSystemDuplicateTypeKind = class extends TypeBoxError {
+  constructor(kind) {
+    super(`Duplicate type kind '${kind}' detected`);
+  }
+};
+var TypeSystemDuplicateFormat = class extends TypeBoxError {
+  constructor(kind) {
+    super(`Duplicate string format '${kind}' detected`);
+  }
+};
+var TypeSystem;
+(function(TypeSystem2) {
+  function Type2(kind, check) {
+    if (type_exports2.Has(kind))
+      throw new TypeSystemDuplicateTypeKind(kind);
+    type_exports2.Set(kind, check);
+    return (options = {}) => Unsafe({ ...options, [Kind]: kind });
+  }
+  TypeSystem2.Type = Type2;
+  function Format(format, check) {
+    if (format_exports.Has(format))
+      throw new TypeSystemDuplicateFormat(format);
+    format_exports.Set(format, check);
+    return format;
+  }
+  TypeSystem2.Format = Format;
+})(TypeSystem || (TypeSystem = {}));
+
+// ../../node_modules/@sinclair/typebox/build/esm/value/hash/hash.mjs
+var ByteMarker;
+(function(ByteMarker2) {
+  ByteMarker2[ByteMarker2["Undefined"] = 0] = "Undefined";
+  ByteMarker2[ByteMarker2["Null"] = 1] = "Null";
+  ByteMarker2[ByteMarker2["Boolean"] = 2] = "Boolean";
+  ByteMarker2[ByteMarker2["Number"] = 3] = "Number";
+  ByteMarker2[ByteMarker2["String"] = 4] = "String";
+  ByteMarker2[ByteMarker2["Object"] = 5] = "Object";
+  ByteMarker2[ByteMarker2["Array"] = 6] = "Array";
+  ByteMarker2[ByteMarker2["Date"] = 7] = "Date";
+  ByteMarker2[ByteMarker2["Uint8Array"] = 8] = "Uint8Array";
+  ByteMarker2[ByteMarker2["Symbol"] = 9] = "Symbol";
+  ByteMarker2[ByteMarker2["BigInt"] = 10] = "BigInt";
+})(ByteMarker || (ByteMarker = {}));
+var Accumulator = BigInt("14695981039346656037");
+var [Prime, Size] = [BigInt("1099511628211"), BigInt("2") ** BigInt("64")];
+var Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+var F64 = new Float64Array(1);
+var F64In = new DataView(F64.buffer);
+var F64Out = new Uint8Array(F64.buffer);
+
+// ../../node_modules/@sinclair/typebox/build/esm/errors/errors.mjs
+var ValueErrorType;
+(function(ValueErrorType2) {
+  ValueErrorType2[ValueErrorType2["ArrayContains"] = 0] = "ArrayContains";
+  ValueErrorType2[ValueErrorType2["ArrayMaxContains"] = 1] = "ArrayMaxContains";
+  ValueErrorType2[ValueErrorType2["ArrayMaxItems"] = 2] = "ArrayMaxItems";
+  ValueErrorType2[ValueErrorType2["ArrayMinContains"] = 3] = "ArrayMinContains";
+  ValueErrorType2[ValueErrorType2["ArrayMinItems"] = 4] = "ArrayMinItems";
+  ValueErrorType2[ValueErrorType2["ArrayUniqueItems"] = 5] = "ArrayUniqueItems";
+  ValueErrorType2[ValueErrorType2["Array"] = 6] = "Array";
+  ValueErrorType2[ValueErrorType2["AsyncIterator"] = 7] = "AsyncIterator";
+  ValueErrorType2[ValueErrorType2["BigIntExclusiveMaximum"] = 8] = "BigIntExclusiveMaximum";
+  ValueErrorType2[ValueErrorType2["BigIntExclusiveMinimum"] = 9] = "BigIntExclusiveMinimum";
+  ValueErrorType2[ValueErrorType2["BigIntMaximum"] = 10] = "BigIntMaximum";
+  ValueErrorType2[ValueErrorType2["BigIntMinimum"] = 11] = "BigIntMinimum";
+  ValueErrorType2[ValueErrorType2["BigIntMultipleOf"] = 12] = "BigIntMultipleOf";
+  ValueErrorType2[ValueErrorType2["BigInt"] = 13] = "BigInt";
+  ValueErrorType2[ValueErrorType2["Boolean"] = 14] = "Boolean";
+  ValueErrorType2[ValueErrorType2["DateExclusiveMaximumTimestamp"] = 15] = "DateExclusiveMaximumTimestamp";
+  ValueErrorType2[ValueErrorType2["DateExclusiveMinimumTimestamp"] = 16] = "DateExclusiveMinimumTimestamp";
+  ValueErrorType2[ValueErrorType2["DateMaximumTimestamp"] = 17] = "DateMaximumTimestamp";
+  ValueErrorType2[ValueErrorType2["DateMinimumTimestamp"] = 18] = "DateMinimumTimestamp";
+  ValueErrorType2[ValueErrorType2["DateMultipleOfTimestamp"] = 19] = "DateMultipleOfTimestamp";
+  ValueErrorType2[ValueErrorType2["Date"] = 20] = "Date";
+  ValueErrorType2[ValueErrorType2["Function"] = 21] = "Function";
+  ValueErrorType2[ValueErrorType2["IntegerExclusiveMaximum"] = 22] = "IntegerExclusiveMaximum";
+  ValueErrorType2[ValueErrorType2["IntegerExclusiveMinimum"] = 23] = "IntegerExclusiveMinimum";
+  ValueErrorType2[ValueErrorType2["IntegerMaximum"] = 24] = "IntegerMaximum";
+  ValueErrorType2[ValueErrorType2["IntegerMinimum"] = 25] = "IntegerMinimum";
+  ValueErrorType2[ValueErrorType2["IntegerMultipleOf"] = 26] = "IntegerMultipleOf";
+  ValueErrorType2[ValueErrorType2["Integer"] = 27] = "Integer";
+  ValueErrorType2[ValueErrorType2["IntersectUnevaluatedProperties"] = 28] = "IntersectUnevaluatedProperties";
+  ValueErrorType2[ValueErrorType2["Intersect"] = 29] = "Intersect";
+  ValueErrorType2[ValueErrorType2["Iterator"] = 30] = "Iterator";
+  ValueErrorType2[ValueErrorType2["Kind"] = 31] = "Kind";
+  ValueErrorType2[ValueErrorType2["Literal"] = 32] = "Literal";
+  ValueErrorType2[ValueErrorType2["Never"] = 33] = "Never";
+  ValueErrorType2[ValueErrorType2["Not"] = 34] = "Not";
+  ValueErrorType2[ValueErrorType2["Null"] = 35] = "Null";
+  ValueErrorType2[ValueErrorType2["NumberExclusiveMaximum"] = 36] = "NumberExclusiveMaximum";
+  ValueErrorType2[ValueErrorType2["NumberExclusiveMinimum"] = 37] = "NumberExclusiveMinimum";
+  ValueErrorType2[ValueErrorType2["NumberMaximum"] = 38] = "NumberMaximum";
+  ValueErrorType2[ValueErrorType2["NumberMinimum"] = 39] = "NumberMinimum";
+  ValueErrorType2[ValueErrorType2["NumberMultipleOf"] = 40] = "NumberMultipleOf";
+  ValueErrorType2[ValueErrorType2["Number"] = 41] = "Number";
+  ValueErrorType2[ValueErrorType2["ObjectAdditionalProperties"] = 42] = "ObjectAdditionalProperties";
+  ValueErrorType2[ValueErrorType2["ObjectMaxProperties"] = 43] = "ObjectMaxProperties";
+  ValueErrorType2[ValueErrorType2["ObjectMinProperties"] = 44] = "ObjectMinProperties";
+  ValueErrorType2[ValueErrorType2["ObjectRequiredProperty"] = 45] = "ObjectRequiredProperty";
+  ValueErrorType2[ValueErrorType2["Object"] = 46] = "Object";
+  ValueErrorType2[ValueErrorType2["Promise"] = 47] = "Promise";
+  ValueErrorType2[ValueErrorType2["RegExp"] = 48] = "RegExp";
+  ValueErrorType2[ValueErrorType2["StringFormatUnknown"] = 49] = "StringFormatUnknown";
+  ValueErrorType2[ValueErrorType2["StringFormat"] = 50] = "StringFormat";
+  ValueErrorType2[ValueErrorType2["StringMaxLength"] = 51] = "StringMaxLength";
+  ValueErrorType2[ValueErrorType2["StringMinLength"] = 52] = "StringMinLength";
+  ValueErrorType2[ValueErrorType2["StringPattern"] = 53] = "StringPattern";
+  ValueErrorType2[ValueErrorType2["String"] = 54] = "String";
+  ValueErrorType2[ValueErrorType2["Symbol"] = 55] = "Symbol";
+  ValueErrorType2[ValueErrorType2["TupleLength"] = 56] = "TupleLength";
+  ValueErrorType2[ValueErrorType2["Tuple"] = 57] = "Tuple";
+  ValueErrorType2[ValueErrorType2["Uint8ArrayMaxByteLength"] = 58] = "Uint8ArrayMaxByteLength";
+  ValueErrorType2[ValueErrorType2["Uint8ArrayMinByteLength"] = 59] = "Uint8ArrayMinByteLength";
+  ValueErrorType2[ValueErrorType2["Uint8Array"] = 60] = "Uint8Array";
+  ValueErrorType2[ValueErrorType2["Undefined"] = 61] = "Undefined";
+  ValueErrorType2[ValueErrorType2["Union"] = 62] = "Union";
+  ValueErrorType2[ValueErrorType2["Void"] = 63] = "Void";
+})(ValueErrorType || (ValueErrorType = {}));
+
+// ../../node_modules/@sinclair/typebox/build/esm/value/delta/delta.mjs
+var Insert = Object2({
+  type: Literal("insert"),
+  path: String(),
+  value: Unknown()
+});
+var Update = Object2({
+  type: Literal("update"),
+  path: String(),
+  value: Unknown()
+});
+var Delete3 = Object2({
+  type: Literal("delete"),
+  path: String()
+});
+var Edit = Union([Insert, Update, Delete3]);
+
+// ../noya-schemas/src/SchemaTree.ts
+var import_tree_visit = __toESM(require_lib());
+var SchemaTree = (0, import_tree_visit.defineTree)((schema) => {
+  if (type_exports.IsUnion(schema)) {
+    return schema.anyOf;
+  } else if (type_exports.IsObject(schema)) {
+    return Object.values(schema.properties);
+  } else if (type_exports.IsArray(schema)) {
+    return [schema.items];
+  }
+  return [];
+}).withOptions({
+  getLabel(node) {
+    return node[Kind] ?? "<UnknownKind>";
+  }
+});
+function findAllDefs(schema) {
+  if (!schema) return [];
+  return SchemaTree.flatMap(schema, (node) => {
+    return node.$id ? [node] : [];
   });
 }
 
+// ../noya-schemas/src/index.ts
+function validateUUID(value) {
+  return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(
+    value
+  );
+}
+format_exports.Set("color", () => true);
+format_exports.Set("uuid", validateUUID);
+
 // src/noyaApp.ts
 var import_state_manager2 = require("@noya-app/state-manager");
 var import_react7 = require("react");
@@ -1332,7 +5014,7 @@ function enforceSchema(initialState, schema) {
   return schema ? (0, import_state_manager2.createOrCastValue)({
     schema,
     value: initialState,
-    defs: (0, import_state_manager2.findAllDefs)(schema)
+    defs: findAllDefs(schema)
   }) : initialState;
 }
 function parseAppDataParameter(options) {
@@ -1461,6 +5143,18 @@ function useSecret(name) {
     (0, import_react8.useCallback)((secrets) => secrets.find((s) => s.name === name), [name])
   );
 }
+function useInputs() {
+  const { noyaManager } = useAnyNoyaStateContext();
+  return useObservable(noyaManager.ioManager.inputs$);
+}
+function useOutputTransforms() {
+  const { noyaManager } = useAnyNoyaStateContext();
+  return useObservable(noyaManager.ioManager.outputTransforms$);
+}
+function useIOManager() {
+  const { noyaManager } = useAnyNoyaStateContext();
+  return noyaManager.ioManager;
+}
 function useIsInitialized() {
   const { noyaManager, viewType } = useAnyNoyaStateContext();
   const isInitializedObservable = (0, import_react8.useMemo)(
@@ -1476,9 +5170,9 @@ function useIsInitialized() {
   );
   return useObservable(isInitializedObservable);
 }
-function useWorkflowManager() {
+function usePipelineManager() {
   const { noyaManager } = useAnyNoyaStateContext();
-  return noyaManager.workflowManager;
+  return noyaManager.pipelineManager;
 }
 var ConnectedUsersContext = (0, import_react8.createContext)(void 0);
 function useConnectedUsersManager() {
@@ -1501,7 +5195,9 @@ var FallbackUntilInitialized = ({
 };
 function createNoyaContext({
   schema,
-  mergeHistoryEntries
+  mergeHistoryEntries,
+  outputTransforms,
+  inputs
 }) {
   const NoyaStateContext = AnyNoyaStateContext;
   const EphemeralUserDataManagerContext = AnyEphemeralUserDataManagerContext;
@@ -1513,9 +5209,11 @@ function createNoyaContext({
     const [, , { noyaManager, theme, viewType }] = useNoyaState(
       initialState,
       {
-        ...options,
         schema,
-        mergeHistoryEntries
+        mergeHistoryEntries,
+        outputTransforms,
+        inputs,
+        ...options
       }
     );
     const contextValue = (0, import_react8.useMemo)(
@@ -1667,32 +5365,13 @@ var WebSocketConnection = class {
     });
   }
   ws;
-  pingCount = 0;
-  pendingPingId;
-  intervalId;
+  closedForever = false;
   async connect() {
+    if (this.closedForever) return;
     this.ws.connect(this.url.toString());
-    this.intervalId = setInterval(() => {
-      if (this.ws.state !== "OPEN") return;
-      if (this.pendingPingId) {
-        this.ws.close();
-        return;
-      }
-      const pingId = (this.pingCount++).toString();
-      const message = {
-        type: "ping",
-        id: pingId
-      };
-      this.pendingPingId = message.id;
-      this.options.onConnectionEvent?.({
-        type: "send",
-        message
-      });
-      this.ws.send(JSON.stringify(message));
-    }, 1e4);
   }
   handleOpen = () => {
-    this.pendingPingId = void 0;
+    if (this.closedForever) return;
     if (this.options.debug) {
       console.info("ws connected");
     }
@@ -1702,6 +5381,7 @@ var WebSocketConnection = class {
     });
   };
   handleMessage = (event) => {
+    if (this.closedForever) return;
     if (this.options.debug) {
       console.info("ws receiving message ", event.data);
     }
@@ -1710,12 +5390,9 @@ var WebSocketConnection = class {
       type: "receive",
       message: parsed
     });
-    if (parsed.type === "pong" && parsed.id === this.pendingPingId) {
-      this.pendingPingId = void 0;
-    }
   };
   handleClose = () => {
-    this.pendingPingId = void 0;
+    if (this.closedForever) return;
     if (this.options.debug) {
       console.info("ws disconnected");
     }
@@ -1725,6 +5402,7 @@ var WebSocketConnection = class {
     });
   };
   send(message) {
+    if (this.closedForever) return;
     if (this.options.debug) {
       console.info("ws sending message", message);
     }
@@ -1735,10 +5413,12 @@ var WebSocketConnection = class {
     this.ws.send(JSON.stringify(message));
   }
   close() {
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-    }
+    if (this.closedForever) return;
+    this.closedForever = true;
     this.ws.shutdown();
+    this.ws.listeners.forEach((listener) => {
+      this.ws.removeListener(listener);
+    });
   }
   addListener(listener) {
     return this.ws.addListener(listener);
@@ -1770,18 +5450,21 @@ var WebSocketConnection = class {
   useColorScheme,
   useConnectedUsersManager,
   useCurrentUserId,
+  useIOManager,
+  useInputs,
   useIsInitialized,
   useManagedHistory,
   useManagedState,
   useMultiplayerState,
   useNoyaState,
   useObservable,
+  useOutputTransforms,
+  usePipelineManager,
   useSecret,
   useSecretManager,
   useSecrets,
   useSyncStateManager,
   useViewType,
-  useWorkflowManager,
   ...require("@noya-app/state-manager")
 });
 //# sourceMappingURL=index.js.map