@camstack/addon-pipeline-orchestrator 0.1.17 → 0.1.20

package/dist/index-Cfo7sGh_.mjs

@@ -1,2054 +0,0 @@
-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
-};