@camstack/addon-pipeline-orchestrator 0.1.15 → 0.1.17

package/dist/index-Cfo7sGh_.mjs

@@ -0,0 +1,2054 @@
+import { i as __mf_7, b as __mf_3, A as __mf_26, n as __mf_13 } from "./__mfe_internal__addon_pipeline_orchestrator_widgets__loadShare___mf_0_trpc_mf_1_client__loadShare__.mjs-DhUh9Qzt.mjs";
+import { a as __mf_429, b as __mf_411 } from "./__mfe_internal__addon_pipeline_orchestrator_widgets__loadShare___mf_0_camstack_mf_1_types__loadShare__.mjs-DrteYOPu.mjs";
+class DoubleIndexedKV {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map();
+    this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.keyToValue.set(key, value);
+    this.valueToKey.set(value, key);
+  }
+  getByKey(key) {
+    return this.keyToValue.get(key);
+  }
+  getByValue(value) {
+    return this.valueToKey.get(value);
+  }
+  clear() {
+    this.keyToValue.clear();
+    this.valueToKey.clear();
+  }
+}
+class Registry {
+  constructor(generateIdentifier) {
+    this.generateIdentifier = generateIdentifier;
+    this.kv = new DoubleIndexedKV();
+  }
+  register(value, identifier) {
+    if (this.kv.getByValue(value)) {
+      return;
+    }
+    if (!identifier) {
+      identifier = this.generateIdentifier(value);
+    }
+    this.kv.set(identifier, value);
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(value) {
+    return this.kv.getByValue(value);
+  }
+  getValue(identifier) {
+    return this.kv.getByKey(identifier);
+  }
+}
+class ClassRegistry extends Registry {
+  constructor() {
+    super((c) => c.name);
+    this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(value, options) {
+    if (typeof options === "object") {
+      if (options.allowProps) {
+        this.classToAllowedProps.set(value, options.allowProps);
+      }
+      super.register(value, options.identifier);
+    } else {
+      super.register(value, options);
+    }
+  }
+  getAllowedProps(value) {
+    return this.classToAllowedProps.get(value);
+  }
+}
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  const values = [];
+  for (const key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  const values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  const valuesNotNever = values;
+  for (let i = 0; i < valuesNotNever.length; i++) {
+    const value = valuesNotNever[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (let i = 0; i < record.length; i++) {
+    const value = record[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+class CustomTransformerRegistry {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(transformer) {
+    this.transfomers[transformer.name] = transformer;
+  }
+  findApplicable(v) {
+    return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+  }
+  findByName(name) {
+    return this.transfomers[name];
+  }
+}
+const getType$1 = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+const isUndefined = (payload) => typeof payload === "undefined";
+const isNull = (payload) => payload === null;
+const isPlainObject$1 = (payload) => {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  if (payload === Object.prototype)
+    return false;
+  if (Object.getPrototypeOf(payload) === null)
+    return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+const isEmptyObject = (payload) => isPlainObject$1(payload) && Object.keys(payload).length === 0;
+const isArray$1 = (payload) => Array.isArray(payload);
+const isString = (payload) => typeof payload === "string";
+const isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+const isBoolean = (payload) => typeof payload === "boolean";
+const isRegExp = (payload) => payload instanceof RegExp;
+const isMap = (payload) => payload instanceof Map;
+const isSet = (payload) => payload instanceof Set;
+const isSymbol = (payload) => getType$1(payload) === "Symbol";
+const isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+const isError = (payload) => payload instanceof Error;
+const isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+const isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+const isBigint = (payload) => typeof payload === "bigint";
+const isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+const isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+const isURL = (payload) => payload instanceof URL;
+const escapeKey = (key) => key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
+const stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+const parsePath = (string, legacyPaths) => {
+  const result = [];
+  let segment = "";
+  for (let i = 0; i < string.length; i++) {
+    let char = string.charAt(i);
+    if (!legacyPaths && char === "\\") {
+      const escaped = string.charAt(i + 1);
+      if (escaped === "\\") {
+        segment += "\\";
+        i++;
+        continue;
+      } else if (escaped !== ".") {
+        throw Error("invalid path");
+      }
+    }
+    const isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
+    if (isEscapedDot) {
+      segment += ".";
+      i++;
+      continue;
+    }
+    const isEndOfSegment = char === ".";
+    if (isEndOfSegment) {
+      result.push(segment);
+      segment = "";
+      continue;
+    }
+    segment += char;
+  }
+  const lastSegment = segment;
+  result.push(lastSegment);
+  return result;
+};
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+const simpleRules = [
+  simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+  simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    console.error("Please add a BigInt polyfill.");
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+  simpleTransformation(isError, "Error", (v, superJson) => {
+    const baseError = {
+      name: v.name,
+      message: v.message
+    };
+    if ("cause" in v) {
+      baseError.cause = v.cause;
+    }
+    superJson.allowedErrorProps.forEach((prop) => {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, (v, superJson) => {
+    const e = new Error(v.message, { cause: v.cause });
+    e.name = v.name;
+    e.stack = v.stack;
+    superJson.allowedErrorProps.forEach((prop) => {
+      e[prop] = v[prop];
+    });
+    return e;
+  }),
+  simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+    const body = regex.slice(1, regex.lastIndexOf("/"));
+    const flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (v) => [...v.values()],
+    (v) => new Set(v)
+  ),
+  simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+  simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+const symbolRule = compositeTransformation((s, superJson) => {
+  if (isSymbol(s)) {
+    const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+    return isRegistered;
+  }
+  return false;
+}, (s, superJson) => {
+  const identifier = superJson.symbolRegistry.getIdentifier(s);
+  return ["symbol", identifier];
+}, (v) => v.description, (_, a, superJson) => {
+  const value = superJson.symbolRegistry.getValue(a[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+const constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((obj, ctor) => {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+const typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
+  const ctor = constructorToName[a[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass?.constructor) {
+    const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+const classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+  const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, (clazz, superJson) => {
+  const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return { ...clazz };
+  }
+  const result = {};
+  allowedProps.forEach((prop) => {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, (v, a, superJson) => {
+  const clazz = superJson.classRegistry.getValue(a[1]);
+  if (!clazz) {
+    throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+const customRule = compositeTransformation((value, superJson) => {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, (v, a, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+const compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+const transformValue = (value, superJson) => {
+  const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+const simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+const untransformValue = (json, type, superJson) => {
+  if (isArray$1(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    const transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+const getNthKey = (value, n) => {
+  if (n > value.size)
+    throw new Error("index out of bounds");
+  const keys = value.keys();
+  while (n > 0) {
+    keys.next();
+    n--;
+  }
+  return keys.next().value;
+};
+function validatePath(path) {
+  if (includes(path, "__proto__")) {
+    throw new Error("__proto__ is not allowed as a property");
+  }
+  if (includes(path, "prototype")) {
+    throw new Error("prototype is not allowed as a property");
+  }
+  if (includes(path, "constructor")) {
+    throw new Error("constructor is not allowed as a property");
+  }
+}
+const getDeep = (object, path) => {
+  validatePath(path);
+  for (let i = 0; i < path.length; i++) {
+    const key = path[i];
+    if (isSet(object)) {
+      object = getNthKey(object, +key);
+    } else if (isMap(object)) {
+      const row = +key;
+      const type = +path[++i] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(object, row);
+      switch (type) {
+        case "key":
+          object = keyOfRow;
+          break;
+        case "value":
+          object = object.get(keyOfRow);
+          break;
+      }
+    } else {
+      object = object[key];
+    }
+  }
+  return object;
+};
+const setDeep = (object, path, mapper) => {
+  validatePath(path);
+  if (path.length === 0) {
+    return mapper(object);
+  }
+  let parent = object;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (isArray$1(parent)) {
+      const index = +key;
+      parent = parent[index];
+    } else if (isPlainObject$1(parent)) {
+      parent = parent[key];
+    } else if (isSet(parent)) {
+      const row = +key;
+      parent = getNthKey(parent, row);
+    } else if (isMap(parent)) {
+      const isEnd = i === path.length - 2;
+      if (isEnd) {
+        break;
+      }
+      const row = +key;
+      const type = +path[++i] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(parent, row);
+      switch (type) {
+        case "key":
+          parent = keyOfRow;
+          break;
+        case "value":
+          parent = parent.get(keyOfRow);
+          break;
+      }
+    }
+  }
+  const lastKey = path[path.length - 1];
+  if (isArray$1(parent)) {
+    parent[+lastKey] = mapper(parent[+lastKey]);
+  } else if (isPlainObject$1(parent)) {
+    parent[lastKey] = mapper(parent[lastKey]);
+  }
+  if (isSet(parent)) {
+    const oldValue = getNthKey(parent, +lastKey);
+    const newValue = mapper(oldValue);
+    if (oldValue !== newValue) {
+      parent.delete(oldValue);
+      parent.add(newValue);
+    }
+  }
+  if (isMap(parent)) {
+    const row = +path[path.length - 2];
+    const keyToRow = getNthKey(parent, row);
+    const type = +lastKey === 0 ? "key" : "value";
+    switch (type) {
+      case "key": {
+        const newKey = mapper(keyToRow);
+        parent.set(newKey, parent.get(keyToRow));
+        if (newKey !== keyToRow) {
+          parent.delete(keyToRow);
+        }
+        break;
+      }
+      case "value": {
+        parent.set(keyToRow, mapper(parent.get(keyToRow)));
+        break;
+      }
+    }
+  }
+  return object;
+};
+const enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker2, version, origin = []) {
+  if (!tree) {
+    return;
+  }
+  const legacyPaths = enableLegacyPaths(version);
+  if (!isArray$1(tree)) {
+    forEach(tree, (subtree, key) => traverse(subtree, walker2, version, [
+      ...origin,
+      ...parsePath(key, legacyPaths)
+    ]));
+    return;
+  }
+  const [nodeValue, children] = tree;
+  if (children) {
+    forEach(children, (child, key) => {
+      traverse(child, walker2, version, [
+        ...origin,
+        ...parsePath(key, legacyPaths)
+      ]);
+    });
+  }
+  walker2(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, version, superJson) {
+  traverse(annotations, (type, path) => {
+    plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+  }, version);
+  return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations, version) {
+  const legacyPaths = enableLegacyPaths(version);
+  function apply(identicalPaths, path) {
+    const object = getDeep(plain, parsePath(path, legacyPaths));
+    identicalPaths.map((path2) => parsePath(path2, legacyPaths)).forEach((identicalObjectPath) => {
+      plain = setDeep(plain, identicalObjectPath, () => object);
+    });
+  }
+  if (isArray$1(annotations)) {
+    const [root, other] = annotations;
+    root.forEach((identicalPath) => {
+      plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
+    });
+    if (other) {
+      forEach(other, apply);
+    }
+  } else {
+    forEach(annotations, apply);
+  }
+  return plain;
+}
+const isDeep = (object, superJson) => isPlainObject$1(object) || isArray$1(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+  const existingSet = identities.get(object);
+  if (existingSet) {
+    existingSet.push(path);
+  } else {
+    identities.set(object, [path]);
+  }
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+  const result = {};
+  let rootEqualityPaths = void 0;
+  identitites.forEach((paths) => {
+    if (paths.length <= 1) {
+      return;
+    }
+    if (!dedupe) {
+      paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
+    }
+    const [representativePath, ...identicalPaths] = paths;
+    if (representativePath.length === 0) {
+      rootEqualityPaths = identicalPaths.map(stringifyPath);
+    } else {
+      result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+    }
+  });
+  if (rootEqualityPaths) {
+    if (isEmptyObject(result)) {
+      return [rootEqualityPaths];
+    } else {
+      return [rootEqualityPaths, result];
+    }
+  } else {
+    return isEmptyObject(result) ? void 0 : result;
+  }
+}
+const walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+  const primitive = isPrimitive(object);
+  if (!primitive) {
+    addIdentity(object, path, identities);
+    const seen = seenObjects.get(object);
+    if (seen) {
+      return dedupe ? {
+        transformedValue: null
+      } : seen;
+    }
+  }
+  if (!isDeep(object, superJson)) {
+    const transformed2 = transformValue(object, superJson);
+    const result2 = transformed2 ? {
+      transformedValue: transformed2.value,
+      annotations: [transformed2.type]
+    } : {
+      transformedValue: object
+    };
+    if (!primitive) {
+      seenObjects.set(object, result2);
+    }
+    return result2;
+  }
+  if (includes(objectsInThisPath, object)) {
+    return {
+      transformedValue: null
+    };
+  }
+  const transformationResult = transformValue(object, superJson);
+  const transformed = transformationResult?.value ?? object;
+  const transformedValue = isArray$1(transformed) ? [] : {};
+  const innerAnnotations = {};
+  forEach(transformed, (value, index) => {
+    if (index === "__proto__" || index === "constructor" || index === "prototype") {
+      throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+    }
+    const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (isArray$1(recursiveResult.annotations)) {
+      innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
+    } else if (isPlainObject$1(recursiveResult.annotations)) {
+      forEach(recursiveResult.annotations, (tree, key) => {
+        innerAnnotations[escapeKey(index) + "." + key] = tree;
+      });
+    }
+  });
+  const result = isEmptyObject(innerAnnotations) ? {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type] : void 0
+  } : {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+  };
+  if (!primitive) {
+    seenObjects.set(object, result);
+  }
+  return result;
+};
+function getType(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+function isArray(payload) {
+  return getType(payload) === "Array";
+}
+function isPlainObject(payload) {
+  if (getType(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (includeNonenumerable && propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function copy(target, options = {}) {
+  if (isArray(target)) {
+    return target.map((item) => copy(item, options));
+  }
+  if (!isPlainObject(target)) {
+    return target;
+  }
+  const props = Object.getOwnPropertyNames(target);
+  const symbols = Object.getOwnPropertySymbols(target);
+  return [...props, ...symbols].reduce((carry, key) => {
+    if (key === "__proto__")
+      return carry;
+    if (isArray(options.props) && !options.props.includes(key)) {
+      return carry;
+    }
+    const val = target[key];
+    const newVal = copy(val, options);
+    assignProp(carry, key, newVal, target, options.nonenumerable);
+    return carry;
+  }, {});
+}
+class SuperJSON {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe = false } = {}) {
+    this.classRegistry = new ClassRegistry();
+    this.symbolRegistry = new Registry((s) => s.description ?? "");
+    this.customTransformerRegistry = new CustomTransformerRegistry();
+    this.allowedErrorProps = [];
+    this.dedupe = dedupe;
+  }
+  serialize(object) {
+    const identities = /* @__PURE__ */ new Map();
+    const output = walker(object, identities, this, this.dedupe);
+    const res = {
+      json: output.transformedValue
+    };
+    if (output.annotations) {
+      res.meta = {
+        ...res.meta,
+        values: output.annotations
+      };
+    }
+    const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+    if (equalityAnnotations) {
+      res.meta = {
+        ...res.meta,
+        referentialEqualities: equalityAnnotations
+      };
+    }
+    if (res.meta)
+      res.meta.v = 1;
+    return res;
+  }
+  deserialize(payload, options) {
+    const { json, meta } = payload;
+    let result = options?.inPlace ? json : copy(json);
+    if (meta?.values) {
+      result = applyValueAnnotations(result, meta.values, meta.v ?? 0, this);
+    }
+    if (meta?.referentialEqualities) {
+      result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, meta.v ?? 0);
+    }
+    return result;
+  }
+  stringify(object) {
+    return JSON.stringify(this.serialize(object));
+  }
+  parse(string) {
+    return this.deserialize(JSON.parse(string), { inPlace: true });
+  }
+  registerClass(v, options) {
+    this.classRegistry.register(v, options);
+  }
+  registerSymbol(v, identifier) {
+    this.symbolRegistry.register(v, identifier);
+  }
+  registerCustom(transformer, name) {
+    this.customTransformerRegistry.register({
+      name,
+      ...transformer
+    });
+  }
+  allowErrorProps(...props) {
+    this.allowedErrorProps.push(...props);
+  }
+}
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+SuperJSON.serialize;
+SuperJSON.deserialize;
+SuperJSON.stringify;
+SuperJSON.parse;
+SuperJSON.registerClass;
+SuperJSON.registerCustom;
+SuperJSON.registerSymbol;
+SuperJSON.allowErrorProps;
+const WS_KEEP_ALIVE_INTERVAL_MS = 1e4;
+const WS_KEEP_ALIVE_PONG_TIMEOUT_MS = 3e3;
+const WS_RECONNECT_RETRY_DELAY_MS = 2e3;
+const WS_RECONNECT_MAX_RETRY_DELAY_MS = 3e4;
+class System {
+  /** Active server base URL. Mutable via `switchServerUrl()` so the
+   *  endpoint-race helper can pivot the transport onto a LAN candidate
+   *  after the initial public-URL bootstrap. */
+  _serverUrl;
+  useWs;
+  baseRetryMs;
+  maxRetryMs;
+  onConnectionChange;
+  token;
+  _trpcClient;
+  _wsClient = null;
+  // Mirror — owns binding cache + state mirror + lifecycle listeners.
+  // Lazily initialised on `init()`. Subsequent `reconnect()` disposes
+  // the old mirror and rebuilds against the new tRPC client.
+  mirror = null;
+  mirrorInit = null;
+  // Transport-readiness probe state. `connected` flips true the first
+  // time `auth.me` succeeds against the current tRPC client; resets
+  // on every `reconnect()` / `close()` so the next consumer waits for
+  // a fresh handshake before issuing queries.
+  connected = false;
+  connectedPromise = null;
+  // System-cap namespaces — populated in the constructor from
+  // `createSystemProxy(api)`. Each namespace is a `Pick<InferProvider<typeof cap>, …>`
+  // shape generated by `scripts/generate-system-proxy.ts`.
+  _systemProxy;
+  // Connection-version + listener bookkeeping for the admin UI's
+  // reconnect watchdog.
+  _connectionVersion = 0;
+  connectionListeners = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this._serverUrl = config.serverUrl.replace(/\/+$/, "");
+    this.token = config.token;
+    const isBrowser = typeof window !== "undefined";
+    this.useWs = config.useWebSocket ?? isBrowser;
+    this.onConnectionChange = config.onConnectionChange;
+    this.baseRetryMs = config.retryDelayMs ?? WS_RECONNECT_RETRY_DELAY_MS;
+    this.maxRetryMs = config.maxRetryDelayMs ?? WS_RECONNECT_MAX_RETRY_DELAY_MS;
+    this._trpcClient = this.buildTrpcClient();
+    this._systemProxy = __mf_429(this._trpcClient);
+  }
+  // ── Connection state ─────────────────────────────────────────────
+  /** Active server base URL (no trailing slash). */
+  get serverUrl() {
+    return this._serverUrl;
+  }
+  get connectionVersion() {
+    return this._connectionVersion;
+  }
+  /**
+   * Subscribe to connection-state transitions. Called with `('connected'
+   * | 'disconnected' | 'connecting', version)` whenever the SDK opens,
+   * closes, or starts a manual reconnect. Listener errors are swallowed
+   * so a misbehaving consumer cannot break the SDK's event loop.
+   */
+  subscribeConnectionEvents(cb) {
+    this.connectionListeners.add(cb);
+    return () => {
+      this.connectionListeners.delete(cb);
+    };
+  }
+  emitConnectionEvent(state) {
+    try {
+      this.onConnectionChange?.(state);
+    } catch {
+    }
+    for (const l of this.connectionListeners) {
+      try {
+        l(state, this._connectionVersion);
+      } catch {
+      }
+    }
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────
+  /**
+   * Wait until the underlying tRPC transport is connected AND the
+   * server has responded to a cheap auth round-trip (`auth.me`). This
+   * is the canonical "ready to issue queries" gate.
+   *
+   * Why a probe, not just `ws.readyState === OPEN`?
+   *   The WS handshake completes asynchronously: tRPC's `wsLink`
+   *   queues outgoing messages and only flushes them after `open()`
+   *   resolves (post `connectionParams` send). On the server, the
+   *   tRPC context is created lazily once the connectionParams
+   *   message is received. A query fired between WS-open and
+   *   connection-params-processed is technically queued by tRPC, but
+   *   the auth context for that query is only resolved once the
+   *   handshake message is decoded server-side. A probe round-trip is
+   *   the safest way to confirm both sides have agreed on the auth
+   *   identity before the React tree starts firing parallel queries
+   *   (which can otherwise land before any addon-side service
+   *   discovery has settled, returning empty results that get cached).
+   *
+   * Idempotent — concurrent callers await the same in-flight Promise.
+   * Bounded by `timeoutMs` (default 15s) — beyond which a
+   * `Error('System.awaitConnected: probe timed out after Xms')` is
+   * thrown so the host can render a clear error state instead of
+   * hanging on a bricked socket.
+   */
+  async awaitConnected(timeoutMs) {
+    if (this.connected) return;
+    if (this.connectedPromise) return this.connectedPromise;
+    const effectiveTimeoutMs = timeoutMs ?? 15e3;
+    this.connectedPromise = (async () => {
+      const probe = this._trpcClient.auth.me.query();
+      if (!Number.isFinite(effectiveTimeoutMs)) {
+        await probe;
+      } else {
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(
+            () => reject(new Error(`System.awaitConnected: probe timed out after ${effectiveTimeoutMs}ms`)),
+            effectiveTimeoutMs
+          );
+          probe.then(
+            () => {
+              clearTimeout(timer);
+              resolve();
+            },
+            (err) => {
+              clearTimeout(timer);
+              reject(err instanceof Error ? err : new Error(String(err)));
+            }
+          );
+        });
+      }
+      this.connected = true;
+    })();
+    try {
+      await this.connectedPromise;
+    } finally {
+      this.connectedPromise = null;
+    }
+  }
+  /**
+   * Warm-boot the device mirror. Awaits the transport probe first
+   * (`awaitConnected`) so the three mirror round-trips
+   * (`getAllBindings` + `getAllSnapshots` + `listAll`) cannot race
+   * against the WS auth handshake. Subsequent `getDevice(id)` calls
+   * are sync; live `device.*` event subscriptions keep the caches
+   * fresh.
+   *
+   * Idempotent — concurrent callers await the same in-flight Promise.
+   */
+  async init(timeoutMs) {
+    if (this.mirror?.isReady()) return;
+    if (this.mirrorInit) return this.mirrorInit;
+    const m = new __mf_411(this._trpcClient);
+    this.mirror = m;
+    this.mirrorInit = (async () => {
+      await this.awaitConnected(timeoutMs);
+      await m.init(timeoutMs);
+    })().finally(() => {
+      this.mirrorInit = null;
+    });
+    return this.mirrorInit;
+  }
+  /** Promise that resolves once `init()` has completed. */
+  async awaitReady() {
+    if (this.mirror?.isReady()) return;
+    if (this.mirrorInit) return this.mirrorInit;
+    return this.init();
+  }
+  /** True after `init()` resolves. */
+  isReady() {
+    return this.mirror?.isReady() ?? false;
+  }
+  /** True after the transport probe has succeeded at least once. */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Force a fresh WebSocket handshake. Tears down the wsClient + tRPC
+   * client + mirror (the mirror captures the tRPC reference at
+   * construction time and would otherwise dispatch through a closed
+   * client) and rebuilds them. No-op for HTTP transport.
+   */
+  reconnect() {
+    if (!this.useWs) return;
+    this.emitConnectionEvent("connecting");
+    this._wsClient?.close();
+    this.disposeMirror();
+    this.connected = false;
+    this.connectedPromise = null;
+    this._trpcClient = this.buildTrpcClient();
+    this._systemProxy = __mf_429(this._trpcClient);
+  }
+  /**
+   * Pivot the underlying tRPC transport onto a different base URL.
+   * Used by the endpoint-race flow: the SDK opens against the public
+   * URL the operator provided, calls `localNetwork.getConnectionEndpoints`
+   * to discover LAN candidates, races them, and (when a faster one wins)
+   * calls `switchServerUrl(winner)` to migrate every subsequent query
+   * onto the LAN path without losing auth state.
+   *
+   * Keeps the auth token. Tears down the WS + mirror and rebuilds them
+   * against the new URL — same machinery as `reconnect()` but with a
+   * different target.
+   */
+  switchServerUrl(nextUrl) {
+    const normalized = nextUrl.replace(/\/+$/, "");
+    if (normalized === this._serverUrl) return;
+    this._serverUrl = normalized;
+    this.reconnect();
+  }
+  /**
+   * Race the candidate base URLs reported by the hub's `local-network`
+   * cap, pick the fastest one that responds, and (if it's different
+   * from the current URL) pivot the transport onto it.
+   *
+   * Flow:
+   *   1. Query `localNetwork.getConnectionEndpoints({ port })` over the
+   *      already-authenticated tRPC channel — the cap is auth-gated,
+   *      so the LAN IPs never leak to anonymous callers.
+   *   2. For each candidate, fire a HEAD on `{baseUrl}/trpc/health`
+   *      with a short timeout (default 1500ms). The first 2xx wins.
+   *   3. If the winner differs from `this.serverUrl`, call
+   *      `switchServerUrl(winner)` and return it. Otherwise return
+   *      the current URL unchanged.
+   *
+   * Bounded — if every candidate times out we keep the current URL.
+   * Idempotent — safe to call on every connect / reconnect / network
+   * change event.
+   */
+  async raceConnectionEndpoints(options) {
+    const timeoutMs = options?.perCandidateTimeoutMs ?? 1500;
+    const url = (() => {
+      try {
+        return new URL(this._serverUrl);
+      } catch {
+        return null;
+      }
+    })();
+    const port = url?.port ? Number(url.port) : url?.protocol === "https:" ? 443 : 80;
+    const scheme = url?.protocol === "https:" ? "https" : "http";
+    const proxy = this._trpcClient;
+    const cap = proxy.localNetwork?.getConnectionEndpoints;
+    if (!cap) {
+      return { winner: this._serverUrl, switched: false };
+    }
+    let endpoints;
+    try {
+      const res = await cap.query({ port, ipv4Only: options?.ipv4Only, scheme });
+      endpoints = res.endpoints;
+    } catch {
+      return { winner: this._serverUrl, switched: false };
+    }
+    if (endpoints.length === 0) {
+      return { winner: this._serverUrl, switched: false };
+    }
+    const winner = await raceFastestEndpoint(endpoints.map((e) => e.baseUrl), timeoutMs);
+    if (!winner || winner === this._serverUrl) {
+      return { winner: winner ?? this._serverUrl, switched: false };
+    }
+    this.switchServerUrl(winner);
+    return { winner, switched: true };
+  }
+  /** Tear down WS connection + mirror. The instance is unusable afterwards. */
+  close() {
+    this.disposeMirror();
+    this.connected = false;
+    this.connectedPromise = null;
+    this._wsClient?.close();
+  }
+  disposeMirror() {
+    this.mirror?.dispose();
+    this.mirror = null;
+    this.mirrorInit = null;
+  }
+  // ── Auth ──────────────────────────────────────────────────────────
+  async login(username, password) {
+    const result = await this._trpcClient.auth.login.mutate({ username, password });
+    if (typeof result === "object" && result !== null && "token" in result) {
+      const r = result;
+      const token = r.token;
+      if (typeof token === "string" && r.requiresTotp !== true) this.setToken(token);
+    }
+    return result;
+  }
+  /**
+   * Second leg of the 2FA login. The caller passes the challenge
+   * token returned by `login` (when `requiresTotp: true`) plus the
+   * 6-digit code from the user's authenticator app. On success the
+   * server mints the real session JWT, which we set as the active
+   * token on this client.
+   */
+  async loginVerifyTotp(challengeToken, code) {
+    const result = await this._trpcClient.auth.loginVerifyTotp.mutate({ challengeToken, code });
+    if (typeof result === "object" && result !== null && "token" in result) {
+      const token = result.token;
+      if (typeof token === "string") this.setToken(token);
+    }
+    return result;
+  }
+  async logout() {
+    await this._trpcClient.auth.logout.mutate();
+  }
+  async getMe() {
+    const me = await this._trpcClient.auth.me.query();
+    return me;
+  }
+  // ── Self-service auth (the signed-in user acting on themselves) ─────
+  //
+  // The hand-written `auth.*` router exposes 5 procedures that operate
+  // on `ctx.user` (the JWT-bound identity), distinct from the admin
+  // `user-management` cap that operates on arbitrary userIds. They live
+  // on `System` rather than as codegen'd hooks because `auth.*` is a
+  // legacy core router, not a `.cap.ts` — see the no-restricted-imports
+  // rule in `eslint.config.mjs` for the canonical entry-point design.
+  async changeOwnPassword(input) {
+    const result = await this._trpcClient.auth.changeOwnPassword.mutate(input);
+    return result;
+  }
+  async setupOwnTotp() {
+    const result = await this._trpcClient.auth.setupOwnTotp.mutate();
+    return result;
+  }
+  async confirmOwnTotp(input) {
+    const result = await this._trpcClient.auth.confirmOwnTotp.mutate(input);
+    return result;
+  }
+  async disableOwnTotp() {
+    const result = await this._trpcClient.auth.disableOwnTotp.mutate();
+    return result;
+  }
+  async getOwnTotpStatus() {
+    const result = await this._trpcClient.auth.getOwnTotpStatus.query();
+    return result;
+  }
+  /** Update the auth token (e.g. after login or token refresh). */
+  setToken(token) {
+    this.token = token;
+  }
+  // ── Devices ──────────────────────────────────────────────────────
+  /**
+   * Synchronous snapshot of every device matching the optional filters.
+   * Backed by the `SystemMirror` warm-boot cache — call `init()` first
+   * (or `awaitReady()`) before invoking. Returns an empty array if the
+   * mirror has not yet been booted.
+   *
+   * Each returned proxy has `binding` populated from the mirror's
+   * binding cache (Phase 5 dedup), so consumers no longer need to
+   * make a separate `deviceManager.getBindings` round-trip.
+   */
+  listDevices(filters) {
+    if (!this.mirror) return [];
+    const proxies = filters ? this.mirror.query(filters) : this.mirror.getAllDevices();
+    return proxies.map((p) => this.attachBinding(p));
+  }
+  /**
+   * Sync lookup by numeric id. `null` if the mirror has not been booted
+   * or the device is unknown.
+   */
+  getDevice(deviceId) {
+    const proxy = this.mirror?.getDeviceById(deviceId) ?? null;
+    return proxy ? this.attachBinding(proxy) : null;
+  }
+  /** Sync lookup by display name (exact match). */
+  getDeviceByName(name) {
+    const proxy = this.mirror?.getDeviceByName(name) ?? null;
+    return proxy ? this.attachBinding(proxy) : null;
+  }
+  /** Sync lookup by stableId. */
+  getDeviceByStableId(stableId) {
+    const proxy = this.mirror?.getDeviceByStableId(stableId) ?? null;
+    return proxy ? this.attachBinding(proxy) : null;
+  }
+  /**
+   * Resolve when a device with `deviceId` becomes available. Resolves
+   * immediately if already known; rejects with a timeout error
+   * otherwise (default 30s).
+   */
+  async waitForDevice(deviceId, timeoutMs) {
+    if (!this.mirror) await this.init();
+    const proxy = await this.mirror.waitForDevice(deviceId, timeoutMs ?? 3e4);
+    return this.attachBinding(proxy);
+  }
+  /** Subscribe to `device.registered` events. */
+  onDeviceAdded(cb) {
+    if (!this.mirror) {
+      throw new Error("System.onDeviceAdded: call init() before subscribing");
+    }
+    return this.mirror.onDeviceAdded(cb);
+  }
+  /** Subscribe to `device.unregistered` events. */
+  onDeviceRemoved(cb) {
+    if (!this.mirror) {
+      throw new Error("System.onDeviceRemoved: call init() before subscribing");
+    }
+    return this.mirror.onDeviceRemoved(cb);
+  }
+  /**
+   * Patch the proxy's `binding` field from the mirror's cache. The
+   * generated `createDeviceProxy()` already sets `binding` to the
+   * binding it was constructed with — this is a defensive overwrite
+   * that uses the latest cached entry in case a `binding-changed`
+   * event landed between proxy creation and access.
+   */
+  attachBinding(proxy) {
+    const binding = this.lookupBinding(proxy.deviceId);
+    if (binding === proxy.binding) return proxy;
+    const writable = proxy;
+    writable.binding = binding;
+    return proxy;
+  }
+  /** Fetch the latest cached binding from the mirror, or `null`. */
+  lookupBinding(deviceId) {
+    if (!this.mirror) return null;
+    const proxy = this.mirror.getDeviceById(deviceId);
+    return proxy?.binding ?? null;
+  }
+  // ── System caps ──────────────────────────────────────────────────
+  //
+  // One getter per `scope: 'system'` capability. The actual surface
+  // comes from `createSystemProxy(api)` (codegen). Adding a new
+  // system cap regenerates the proxy and the new namespace surfaces
+  // automatically via `system.<newCap>.<method>(input)`.
+  get addonPages() {
+    return this._systemProxy.addonPages;
+  }
+  get addonSettings() {
+    return this._systemProxy.addonSettings;
+  }
+  get alerts() {
+    return this._systemProxy.alerts;
+  }
+  get audioAnalyzer() {
+    return this._systemProxy.audioAnalyzer;
+  }
+  get audioCodec() {
+    return this._systemProxy.audioCodec;
+  }
+  get backup() {
+    return this._systemProxy.backup;
+  }
+  get decoder() {
+    return this._systemProxy.decoder;
+  }
+  get deviceManager() {
+    return this._systemProxy.deviceManager;
+  }
+  get deviceProvider() {
+    return this._systemProxy.deviceProvider;
+  }
+  get deviceState() {
+    return this._systemProxy.deviceState;
+  }
+  get metricsProvider() {
+    return this._systemProxy.metricsProvider;
+  }
+  get notificationOutput() {
+    return this._systemProxy.notificationOutput;
+  }
+  get pipelineExecutor() {
+    return this._systemProxy.pipelineExecutor;
+  }
+  get pipelineOrchestrator() {
+    return this._systemProxy.pipelineOrchestrator;
+  }
+  get pipelineRunner() {
+    return this._systemProxy.pipelineRunner;
+  }
+  get platformProbe() {
+    return this._systemProxy.platformProbe;
+  }
+  get recordingEngine() {
+    return this._systemProxy.recordingEngine;
+  }
+  get settingsStore() {
+    return this._systemProxy.settingsStore;
+  }
+  get storage() {
+    return this._systemProxy.storage;
+  }
+  get streamBroker() {
+    return this._systemProxy.streamBroker;
+  }
+  get turnProvider() {
+    return this._systemProxy.turnProvider;
+  }
+  get userManagement() {
+    return this._systemProxy.userManagement;
+  }
+  // ── Live events ──────────────────────────────────────────────────
+  /**
+   * Subscribe to a single event category. Returns an unsubscribe
+   * handle. Errors thrown by the listener are swallowed so a single
+   * misbehaving consumer cannot tear down the WS subscription.
+   *
+   * Categories should be values from the `EventCategory` enum
+   * (`@camstack/types`) — passing a raw string works for forward-compat
+   * but loses type safety. The SDK forwards the value verbatim to the
+   * server's `live.onEvent` subscription.
+   */
+  subscribeEvent(category, cb) {
+    const sub = this._trpcClient.live.onEvent.subscribe(
+      { category },
+      {
+        onData: (event) => {
+          try {
+            cb(event);
+          } catch {
+          }
+        }
+      }
+    );
+    return () => {
+      try {
+        sub.unsubscribe();
+      } catch {
+      }
+    };
+  }
+  // ── Escape hatches ───────────────────────────────────────────────
+  //
+  // Kept public so the ui-library `<TrpcProvider>` can seed React
+  // Query with the same WebSocket connection during Phase 2. Phase 4
+  // is expected to revisit whether either field can be hidden.
+  /** Direct tRPC client. Read once per call; rebuilt on `reconnect()`. */
+  get trpcClient() {
+    return this._trpcClient;
+  }
+  /**
+   * Underlying WSClient (or `null` for HTTP transport). Used by
+   * advanced consumers that need direct access to the WebSocket
+   * (e.g. for keep-alive metrics). Rebuilt on `reconnect()`.
+   */
+  get wsClient() {
+    return this._wsClient;
+  }
+  // ── Internals ────────────────────────────────────────────────────
+  buildTrpcClient() {
+    const headers = () => {
+      const h = {};
+      if (this.token) h["Authorization"] = `Bearer ${this.token}`;
+      return h;
+    };
+    if (this.useWs) {
+      const wsUrl = this._serverUrl.replace(/^http/, "ws") + "/trpc";
+      const baseRetryMs = this.baseRetryMs;
+      const maxRetryMs = this.maxRetryMs;
+      this._wsClient = __mf_7({
+        url: wsUrl,
+        connectionParams: () => ({ token: this.token }),
+        retryDelayMs: (attemptIndex) => Math.min(baseRetryMs * Math.pow(2, attemptIndex), maxRetryMs),
+        keepAlive: {
+          enabled: true,
+          intervalMs: WS_KEEP_ALIVE_INTERVAL_MS,
+          pongTimeoutMs: WS_KEEP_ALIVE_PONG_TIMEOUT_MS
+        },
+        onOpen: () => {
+          this._connectionVersion += 1;
+          this.emitConnectionEvent("connected");
+        },
+        onClose: () => {
+          this.emitConnectionEvent("disconnected");
+        }
+      });
+      return __mf_3({
+        links: [__mf_26({ client: this._wsClient, transformer: SuperJSON })]
+      });
+    }
+    this._wsClient = null;
+    return __mf_3({
+      links: [__mf_13({ url: `${this._serverUrl}/trpc`, headers, transformer: SuperJSON })]
+    });
+  }
+}
+function createSystem(config) {
+  return new System(config);
+}
+async function raceFastestEndpoint(candidates, timeoutMs) {
+  if (candidates.length === 0) return null;
+  if (typeof fetch !== "function") return candidates[0] ?? null;
+  const pageIsHttps = typeof window !== "undefined" && typeof window.location !== "undefined" && window.location.protocol === "https:";
+  const reachable = pageIsHttps ? candidates.filter((u) => u.toLowerCase().startsWith("https://")) : candidates;
+  if (reachable.length === 0) return null;
+  const controllers = reachable.map(() => new AbortController());
+  const probes = reachable.map(async (baseUrl, i) => {
+    const ctrl = controllers[i];
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+      const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/trpc/health`, {
+        method: "GET",
+        signal: ctrl.signal,
+        // Cross-origin probes from a browser sandbox are fine — the
+        // /trpc/health response is open-CORS by the Fastify default.
+        // No credentials needed (this is a transport-quality probe,
+        // not an auth round-trip).
+        credentials: "omit"
+      });
+      if (!res.ok) throw new Error(`${res.status}`);
+      return baseUrl;
+    } finally {
+      clearTimeout(timer);
+    }
+  });
+  try {
+    const winner = await Promise.any(probes);
+    for (const c of controllers) {
+      try {
+        c.abort();
+      } catch {
+      }
+    }
+    return winner;
+  } catch {
+    return null;
+  }
+}
+var DetectionClass = /* @__PURE__ */ ((DetectionClass2) => {
+  DetectionClass2["Motion"] = "motion";
+  DetectionClass2["Person"] = "person";
+  DetectionClass2["Vehicle"] = "vehicle";
+  DetectionClass2["Animal"] = "animal";
+  DetectionClass2["Audio"] = "audio";
+  DetectionClass2["Face"] = "face";
+  DetectionClass2["Plate"] = "plate";
+  DetectionClass2["Package"] = "package";
+  DetectionClass2["Doorbell"] = "doorbell";
+  DetectionClass2["Sensor"] = "sensor";
+  return DetectionClass2;
+})(DetectionClass || {});
+const animalClasses = [
+  "animal",
+  "dog_cat",
+  "dog",
+  "cat",
+  "horse",
+  "sheep",
+  "cow",
+  "elephant",
+  "bear",
+  "zebra",
+  "giraffe",
+  "mouse",
+  "rabbit",
+  "deer",
+  "lion",
+  "tiger",
+  "bird",
+  "eagle",
+  "owl",
+  "pigeon",
+  "fish",
+  "whale",
+  "dolphin",
+  "snake",
+  "turtle",
+  "lizard"
+];
+const personClasses = [
+  "person",
+  "people",
+  "pedestrian",
+  "rider",
+  "driver",
+  "cyclist",
+  "skier",
+  "skateboarder",
+  "face",
+  "hand",
+  "head",
+  "body"
+];
+const vehicleClasses = [
+  "vehicle",
+  "car",
+  "truck",
+  "bus",
+  "motorcycle",
+  "bicycle",
+  "van",
+  "ambulance",
+  "police_car",
+  "fire_truck",
+  "train",
+  "subway",
+  "tram",
+  "airplane",
+  "boat",
+  "ship",
+  "helicopter"
+];
+const faceClasses = [
+  "face",
+  "eyes",
+  "nose",
+  "mouth",
+  "ears",
+  "eyebrows",
+  "left_eye",
+  "right_eye",
+  "pupil",
+  "iris",
+  "eyelid",
+  "eye_corner",
+  "upper_lip",
+  "lower_lip",
+  "teeth",
+  "chin",
+  "cheek",
+  "forehead",
+  "jaw",
+  "glasses",
+  "sunglasses",
+  "facial_hair",
+  "beard",
+  "mustache",
+  "facial_landmark",
+  "facial_keypoint"
+];
+const licensePlateClasses = [
+  "plate",
+  "license_plate",
+  "front_plate",
+  "rear_plate",
+  "motorcycle_plate",
+  "temporary_plate",
+  "dealer_plate",
+  "licensePlate",
+  "plate_number",
+  "plate_character",
+  "plate_digit",
+  "plate_letter",
+  "plate_symbol",
+  "plate_region",
+  "plate_country_identifier",
+  "plate_frame",
+  "plate_bolt",
+  "plate_sticker",
+  "plate_validation_tag",
+  "damaged_plate",
+  "obscured_plate",
+  "dirty_plate"
+];
+const motionClasses = ["motion", "movement", "other"];
+const packageClasses = ["package", "packet"];
+const audioClasses = [
+  "audio"
+  /* Audio */
+];
+const audioLabelClasses = [
+  "speech",
+  "scream",
+  "babbling",
+  "yell",
+  "bellow",
+  "whoop",
+  "whispering",
+  "laughter",
+  "snicker",
+  "crying",
+  "cry",
+  "sigh",
+  "singing",
+  "choir",
+  "chant",
+  "mantra",
+  "child_singing",
+  "rapping",
+  "humming",
+  "groan",
+  "grunt",
+  "whistling",
+  "breathing",
+  "wheeze",
+  "snoring",
+  "gasp",
+  "pant",
+  "snort",
+  "cough",
+  "throat_clearing",
+  "sneeze",
+  "sniff",
+  "cheering",
+  "applause",
+  "chatter",
+  "crowd",
+  "children_playing",
+  "bark",
+  "yip",
+  "howl",
+  "bow-wow",
+  "growling",
+  "whimper_dog",
+  "purr",
+  "meow",
+  "hiss",
+  "caterwaul",
+  "pets",
+  "livestock",
+  "doorbell",
+  "ding-dong",
+  "door",
+  "slam",
+  "knock",
+  "alarm",
+  "telephone",
+  "music",
+  "dog",
+  "dogs"
+];
+const doorbellClasses = ["doorbell", "ring"];
+const sensorLabelClasses = [
+  "lock",
+  "binary",
+  "flood",
+  "entry",
+  "door",
+  "leak",
+  "door_open",
+  "flooded",
+  "entry_open"
+];
+const detectionClassesDefaultMap = {
+  ...animalClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "animal"
+    /* Animal */
+  }), {}),
+  ...personClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "person"
+    /* Person */
+  }), {}),
+  ...vehicleClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "vehicle"
+    /* Vehicle */
+  }), {}),
+  ...motionClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "motion"
+    /* Motion */
+  }), {}),
+  ...packageClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "package"
+    /* Package */
+  }), {}),
+  ...faceClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "face"
+    /* Face */
+  }), {}),
+  ...licensePlateClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "plate"
+    /* Plate */
+  }), {}),
+  ...audioClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "audio"
+    /* Audio */
+  }), {}),
+  ...audioLabelClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "audio"
+    /* Audio */
+  }), {}),
+  ...doorbellClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "doorbell"
+    /* Doorbell */
+  }), {}),
+  ...sensorLabelClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "sensor"
+    /* Sensor */
+  }), {})
+};
+const isFaceClassname = (c) => faceClasses.includes(c);
+const isPlateClassname = (c) => licensePlateClasses.includes(c);
+const isAnimalClassname = (c) => animalClasses.includes(c);
+const isPersonClassname = (c) => personClasses.includes(c);
+const isVehicleClassname = (c) => vehicleClasses.includes(c);
+const isMotionClassname = (c) => motionClasses.includes(c);
+const isDoorbellClassname = (c) => doorbellClasses.includes(c);
+const isPackageClassname = (c) => packageClasses.includes(c);
+const isAudioClassname = (c) => audioClasses.includes(c) || audioLabelClasses.includes(c);
+const isSensorLabelClassname = (c) => sensorLabelClasses.includes(c);
+const isLabelDetection = (c) => isFaceClassname(c) || isPlateClassname(c);
+const getParentClass = (className) => detectionClassesDefaultMap[className];
+const getParentDetectionClass = (det) => {
+  const { className } = det;
+  const baseMap = {
+    [
+      "face"
+      /* Face */
+    ]: "person",
+    [
+      "plate"
+      /* Plate */
+    ]: "vehicle"
+    /* Vehicle */
+  };
+  const parentGroup = detectionClassesDefaultMap[className];
+  if (parentGroup && parentGroup !== className) return parentGroup;
+  return baseMap[className];
+};
+const defaultDetectionClasses = Object.values(DetectionClass);
+const DEFAULT_ENABLED_CLASSES = defaultDetectionClasses.filter(
+  (c) => c !== "motion"
+  /* Motion */
+);
+const TIMELINE_PRESET_CRITICAL = [
+  "person",
+  "doorbell",
+  "package"
+  /* Package */
+];
+const TIMELINE_PRESET_IMPORTANT = [
+  ...TIMELINE_PRESET_CRITICAL,
+  "vehicle",
+  "animal",
+  "audio",
+  "face",
+  "plate"
+  /* Plate */
+];
+const TIMELINE_PRESET_ALL = [...DEFAULT_ENABLED_CLASSES];
+function getClassesForTimelinePreset(preset, customClasses) {
+  switch (preset) {
+    case "critical":
+      return TIMELINE_PRESET_CRITICAL;
+    case "important":
+      return TIMELINE_PRESET_IMPORTANT;
+    case "all":
+      return TIMELINE_PRESET_ALL;
+    case "custom":
+      return customClasses?.length ? customClasses : DEFAULT_ENABLED_CLASSES;
+    default:
+      return DEFAULT_ENABLED_CLASSES;
+  }
+}
+const RAW_TO_CANONICAL = {
+  // Scrypted PascalCase
+  Light: "light",
+  Switch: "switch",
+  WindowCovering: "cover",
+  Lock: "lock",
+  SecuritySystem: "alarm",
+  Buttons: "button",
+  Select: "select",
+  Siren: "siren",
+  Sensor: "sensor",
+  Entry: "entry",
+  Program: "script",
+  MediaPlayer: "media_player",
+  Outlet: "switch",
+  // Home Assistant lowercase domains
+  light: "light",
+  switch: "switch",
+  input_boolean: "switch",
+  cover: "cover",
+  lock: "lock",
+  alarm_control_panel: "alarm",
+  input_button: "button",
+  button: "button",
+  input_select: "select",
+  select: "select",
+  siren: "siren",
+  sensor: "sensor",
+  media_player: "media_player",
+  script: "script"
+};
+const HA_DOMAIN_TYPE_MAP = {
+  light: "light",
+  switch: "switch",
+  input_boolean: "switch",
+  cover: "cover",
+  lock: "lock",
+  alarm_control_panel: "alarm",
+  input_button: "button",
+  button: "button",
+  input_select: "select",
+  select: "select",
+  siren: "siren",
+  sensor: "sensor",
+  binary_sensor: "sensor",
+  media_player: "media_player",
+  script: "script",
+  climate: "climate",
+  camera: "camera",
+  fan: "fan",
+  vacuum: "vacuum",
+  automation: "automation",
+  scene: "scene",
+  input_number: "sensor",
+  person: "person",
+  device_tracker: "tracker",
+  weather: "weather",
+  water_heater: "climate"
+};
+const SCRYPTED_TYPE_TO_CANONICAL = {
+  Light: "light",
+  Switch: "switch",
+  WindowCovering: "cover",
+  Lock: "lock",
+  SecuritySystem: "alarm",
+  Buttons: "button",
+  Select: "select",
+  Siren: "siren",
+  Sensor: "sensor",
+  Entry: "entry",
+  Program: "script",
+  MediaPlayer: "media_player",
+  Camera: "camera",
+  Doorbell: "doorbell",
+  Fan: "fan",
+  Outlet: "switch"
+};
+function getCanonicalDeviceType(rawType) {
+  const canonical = RAW_TO_CANONICAL[rawType];
+  if (canonical) return canonical;
+  const lower = rawType.toLowerCase();
+  return RAW_TO_CANONICAL[lower] ?? null;
+}
+const ELIGIBLE_SCRYPTED_DEVICE_TYPES = [
+  "Entry",
+  "Light",
+  "Switch",
+  "Lock",
+  "SecuritySystem",
+  "Buttons",
+  "WindowCovering",
+  "Siren",
+  "Sensor",
+  "Select",
+  "Program"
+];
+const ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET = new Set(ELIGIBLE_SCRYPTED_DEVICE_TYPES);
+const ELIGIBLE_HA_DOMAINS = [
+  "light",
+  "switch",
+  "input_boolean",
+  "cover",
+  "lock",
+  "alarm_control_panel",
+  "input_button",
+  "button",
+  "input_select",
+  "select",
+  "siren",
+  "media_player",
+  "script"
+];
+const ELIGIBLE_HA_DOMAINS_SET = new Set(ELIGIBLE_HA_DOMAINS);
+const FEATURE_MATRIX = [
+  {
+    id: "liveStream",
+    label: "Live Stream",
+    sources: { frigate: true, scrypted: true, rtsp: true },
+    adapterMethod: "getLiveStream"
+  },
+  {
+    id: "multiResolution",
+    label: "Multi-Resolution",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getResolutions"
+  },
+  {
+    id: "motion",
+    label: "Motion Detection",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getMotion"
+  },
+  {
+    id: "objectDetection",
+    label: "Object Detection",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getObjectDetections"
+  },
+  {
+    id: "audioVolume",
+    label: "Audio Level",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getAudioVolume"
+  },
+  {
+    id: "audioVolumes",
+    label: "Audio Volumes (dBFS)",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getAudioVolumes"
+  },
+  {
+    id: "ptz",
+    label: "PTZ Control",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getPTZ"
+  },
+  {
+    id: "intercom",
+    label: "Intercom (Mic)",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getIntercomSupport"
+  },
+  {
+    id: "deviceStatus",
+    label: "Device Status",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "getStatus"
+  },
+  {
+    id: "timeline",
+    label: "Detection Timeline",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getCameraDayData"
+  },
+  {
+    id: "clusteredTimeline",
+    label: "Clustered Timeline",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    requiresBackend: true,
+    adapterMethod: "getClusteredDayData"
+  },
+  {
+    id: "detectionClasses",
+    label: "Detection Classes",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getDetectionClasses"
+  },
+  {
+    id: "videoClips",
+    label: "Video Clips",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getVideoClips"
+  },
+  {
+    id: "nvrPlayback",
+    label: "NVR Playback",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getNvrPlaybackSupported"
+  },
+  {
+    id: "nvrScrub",
+    label: "NVR Scrub/Seek",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "seekRecordingStream"
+  },
+  {
+    id: "recordingThumbnail",
+    label: "Recording Thumbnails",
+    sources: { frigate: true, scrypted: true, rtsp: false },
+    adapterMethod: "getRecordingStreamThumbnail"
+  },
+  {
+    id: "nvrSeekToLive",
+    label: "Seek to Live",
+    sources: { frigate: false, scrypted: true, rtsp: false },
+    adapterMethod: "seekNvrToLive"
+  }
+];
+function isFeatureAvailable(featureId, source, platform) {
+  const entry = FEATURE_MATRIX.find((f) => f.id === featureId);
+  if (!entry) return false;
+  if (!entry.sources[source]) return false;
+  if (entry.platforms && entry.platforms[platform] === false) return false;
+  return true;
+}
+function getSourceFeatures(source) {
+  return FEATURE_MATRIX.filter((f) => f.sources[source]);
+}
+function getBackendRequiredFeatures() {
+  return FEATURE_MATRIX.filter((f) => f.requiresBackend);
+}
+function selectOptimalStream(streams, constraints, defaultTransport) {
+  if (streams.length === 0) return null;
+  const viewportPixels = constraints.viewportWidth * constraints.viewportHeight * (constraints.pixelRatio ?? 1);
+  const bw = constraints.bandwidthMbps ?? 100;
+  const loss = constraints.packetLoss ?? 0;
+  const rtt = constraints.rttMs ?? 50;
+  let targetTier = "high";
+  if (constraints.maxResolution === "low" || constraints.isCellular || bw < 1 || loss > 0.05) {
+    targetTier = "low";
+  } else if (constraints.maxResolution === "medium" || bw < 5 || viewportPixels < 5e5 || rtt > 200) {
+    targetTier = "medium";
+  } else if (constraints.maxResolution === "high" || viewportPixels > 2e6) {
+    targetTier = "high";
+  }
+  const PROFILE_TIER = {
+    main: "high",
+    sub: "medium",
+    ext: "low"
+  };
+  const preferTransport = defaultTransport ?? "native";
+  const scored = streams.map((s) => {
+    let score = 0;
+    const streamTier = PROFILE_TIER[s.profile] ?? "medium";
+    if (streamTier === targetTier) score += 100;
+    else if (targetTier === "high" && streamTier === "medium" || targetTier === "medium" && streamTier === "high" || targetTier === "medium" && streamTier === "low" || targetTier === "low" && streamTier === "medium") score += 50;
+    if (s.transport === preferTransport) score += 30;
+    else if (s.transport === "native") score += 20;
+    else if (s.transport === "rtsp") score += 15;
+    else if (s.transport === "rtmp") score += 10;
+    if (s.metadata?.width && s.metadata?.height) {
+      const streamPixels = s.metadata.width * s.metadata.height;
+      const ratio = streamPixels / Math.max(viewportPixels, 1);
+      if (ratio >= 0.8 && ratio <= 2) score += 25;
+      else if (ratio >= 0.5 && ratio <= 3) score += 15;
+      if (ratio > 4 && bw < 10) score -= 20;
+    }
+    if (s.metadata?.codec) {
+      if (bw < 5 && s.metadata.codec.includes("265")) score += 10;
+      if (bw >= 10 && s.metadata.codec.includes("264")) score += 5;
+    }
+    return { ...s, score, targetTier };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const best = scored[0];
+  return {
+    streamName: best.streamName,
+    profile: best.profile,
+    transport: best.transport,
+    label: best.label,
+    metadata: best.metadata,
+    reason: `${best.targetTier} quality → ${best.profile}/${best.transport} (score: ${best.score})`
+  };
+}
+function getNextEvalInterval(constraints, wasSwitch) {
+  if (wasSwitch) return 10;
+  if (constraints.isCellular) return 15;
+  if ((constraints.packetLoss ?? 0) > 0.02) return 15;
+  return 30;
+}
+export {
+  DEFAULT_ENABLED_CLASSES,
+  DetectionClass,
+  ELIGIBLE_HA_DOMAINS,
+  ELIGIBLE_HA_DOMAINS_SET,
+  ELIGIBLE_SCRYPTED_DEVICE_TYPES,
+  ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET,
+  FEATURE_MATRIX,
+  HA_DOMAIN_TYPE_MAP,
+  RAW_TO_CANONICAL,
+  SCRYPTED_TYPE_TO_CANONICAL,
+  System,
+  TIMELINE_PRESET_ALL,
+  TIMELINE_PRESET_CRITICAL,
+  TIMELINE_PRESET_IMPORTANT,
+  animalClasses,
+  audioClasses,
+  audioLabelClasses,
+  createSystem,
+  defaultDetectionClasses,
+  detectionClassesDefaultMap,
+  doorbellClasses,
+  faceClasses,
+  getBackendRequiredFeatures,
+  getCanonicalDeviceType,
+  getClassesForTimelinePreset,
+  getNextEvalInterval,
+  getParentClass,
+  getParentDetectionClass,
+  getSourceFeatures,
+  isAnimalClassname,
+  isAudioClassname,
+  isDoorbellClassname,
+  isFaceClassname,
+  isFeatureAvailable,
+  isLabelDetection,
+  isMotionClassname,
+  isPackageClassname,
+  isPersonClassname,
+  isPlateClassname,
+  isSensorLabelClassname,
+  isVehicleClassname,
+  licensePlateClasses,
+  motionClasses,
+  packageClasses,
+  personClasses,
+  raceFastestEndpoint,
+  selectOptimalStream,
+  sensorLabelClasses,
+  vehicleClasses
+};