@addozhang/dsh-discord 0.1.0

package/lib/client.js

@@ -0,0 +1,1622 @@
+window.__ModuleLoader__.load({
+  id: "@addozhang/dsh-discord",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var index_exports = {};
+__export(index_exports, {
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/features/adapter-status.ts
+var DISCORD_RPC_CHANNEL = "/dsh-discord";
+var STATUS_ENDPOINT = "adapter.status";
+
+// src/settings-namespace.ts
+var DISCORD_SETTINGS_NAMESPACE = "dsh-discord";
+
+// node_modules/.pnpm/immer@10.2.0/node_modules/immer/dist/immer.mjs
+var NOTHING = Symbol.for("immer-nothing");
+var DRAFTABLE = Symbol.for("immer-draftable");
+var DRAFT_STATE = Symbol.for("immer-state");
+var errors = true ? [
+  // All error codes, starting by 0:
+  function(plugin) {
+    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
+  },
+  function(thing) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(data) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(thing) {
+    return `'current' expects a draft, got: ${thing}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(thing) {
+    return `'original' expects a draft, got: ${thing}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function die(error, ...args) {
+  if (true) {
+    const e = errors[error];
+    const msg = typeof e === "function" ? e.apply(null, args) : e;
+    throw new Error(`[Immer] ${msg}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+  if (!value)
+    return false;
+  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+}
+var objectCtorString = Object.prototype.constructor.toString();
+var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
+function isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype)
+    return true;
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object)
+    return true;
+  if (typeof Ctor !== "function")
+    return false;
+  let ctorString = cachedCtorStrings.get(Ctor);
+  if (ctorString === void 0) {
+    ctorString = Function.toString.call(Ctor);
+    cachedCtorStrings.set(Ctor, ctorString);
+  }
+  return ctorString === objectCtorString;
+}
+function each(obj, iter, strict = true) {
+  if (getArchtype(obj) === 0) {
+    const keys = strict ? Reflect.ownKeys(obj) : Object.keys(obj);
+    keys.forEach((key) => {
+      iter(key, obj[key], obj);
+    });
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
+  }
+}
+function getArchtype(thing) {
+  const state = thing[DRAFT_STATE];
+  return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
+}
+function has(thing, prop) {
+  return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+}
+function set(thing, propOrOldValue, value) {
+  const t = getArchtype(thing);
+  if (t === 2)
+    thing.set(propOrOldValue, value);
+  else if (t === 3) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
+}
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function isMap(target) {
+  return target instanceof Map;
+}
+function isSet(target) {
+  return target instanceof Set;
+}
+function latest(state) {
+  return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
+  }
+  if (isSet(base)) {
+    return new Set(base);
+  }
+  if (Array.isArray(base))
+    return Array.prototype.slice.call(base);
+  const isPlain = isPlainObject(base);
+  if (strict === true || strict === "class_only" && !isPlain) {
+    const descriptors = Object.getOwnPropertyDescriptors(base);
+    delete descriptors[DRAFT_STATE];
+    let keys = Reflect.ownKeys(descriptors);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const desc = descriptors[key];
+      if (desc.writable === false) {
+        desc.writable = true;
+        desc.configurable = true;
+      }
+      if (desc.get || desc.set)
+        descriptors[key] = {
+          configurable: true,
+          writable: true,
+          // could live with !!desc.set as well here...
+          enumerable: desc.enumerable,
+          value: base[key]
+        };
+    }
+    return Object.create(getPrototypeOf(base), descriptors);
+  } else {
+    const proto = getPrototypeOf(base);
+    if (proto !== null && isPlain) {
+      return { ...base };
+    }
+    const obj = Object.create(proto);
+    return Object.assign(obj, base);
+  }
+}
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    Object.defineProperties(obj, {
+      set: dontMutateMethodOverride,
+      add: dontMutateMethodOverride,
+      clear: dontMutateMethodOverride,
+      delete: dontMutateMethodOverride
+    });
+  }
+  Object.freeze(obj);
+  if (deep)
+    Object.values(obj).forEach((value) => freeze(value, true));
+  return obj;
+}
+function dontMutateFrozenCollections() {
+  die(2);
+}
+var dontMutateMethodOverride = {
+  value: dontMutateFrozenCollections
+};
+function isFrozen(obj) {
+  if (obj === null || typeof obj !== "object")
+    return true;
+  return Object.isFrozen(obj);
+}
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
+  }
+  return plugin;
+}
+var currentScope;
+function getCurrentScope() {
+  return currentScope;
+}
+function createScope(parent_, immer_) {
+  return {
+    drafts_: [],
+    parent_,
+    immer_,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: true,
+    unfinalizedDrafts_: 0
+  };
+}
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    getPlugin("Patches");
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
+  }
+}
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
+  }
+}
+function enterScope(immer2) {
+  return currentScope = createScope(currentScope, immer2);
+}
+function revokeDraft(draft) {
+  const state = draft[DRAFT_STATE];
+  if (state.type_ === 0 || state.type_ === 1)
+    state.revoke_();
+  else
+    state.revoked_ = true;
+}
+function processResult(result, scope) {
+  scope.unfinalizedDrafts_ = scope.drafts_.length;
+  const baseDraft = scope.drafts_[0];
+  const isReplaced = result !== void 0 && result !== baseDraft;
+  if (isReplaced) {
+    if (baseDraft[DRAFT_STATE].modified_) {
+      revokeScope(scope);
+      die(4);
+    }
+    if (isDraftable(result)) {
+      result = finalize(scope, result);
+      if (!scope.parent_)
+        maybeFreeze(scope, result);
+    }
+    if (scope.patches_) {
+      getPlugin("Patches").generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope.patches_,
+        scope.inversePatches_
+      );
+    }
+  } else {
+    result = finalize(scope, baseDraft, []);
+  }
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  }
+  return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value, path) {
+  if (isFrozen(value))
+    return value;
+  const useStrictIteration = rootScope.immer_.shouldUseStrictIteration();
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    each(
+      value,
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path),
+      useStrictIteration
+    );
+    return value;
+  }
+  if (state.scope_ !== rootScope)
+    return value;
+  if (!state.modified_) {
+    maybeFreeze(rootScope, state.base_, true);
+    return state.base_;
+  }
+  if (!state.finalized_) {
+    state.finalized_ = true;
+    state.scope_.unfinalizedDrafts_--;
+    const result = state.copy_;
+    let resultEach = result;
+    let isSet2 = false;
+    if (state.type_ === 3) {
+      resultEach = new Set(result);
+      result.clear();
+      isSet2 = true;
+    }
+    each(
+      resultEach,
+      (key, childValue) => finalizeProperty(
+        rootScope,
+        state,
+        result,
+        key,
+        childValue,
+        path,
+        isSet2
+      ),
+      useStrictIteration
+    );
+    maybeFreeze(rootScope, result, false);
+    if (path && rootScope.patches_) {
+      getPlugin("Patches").generatePatches_(
+        state,
+        path,
+        rootScope.patches_,
+        rootScope.inversePatches_
+      );
+    }
+  }
+  return state.copy_;
+}
+function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+  if (childValue == null) {
+    return;
+  }
+  if (typeof childValue !== "object" && !targetIsSet) {
+    return;
+  }
+  const childIsFrozen = isFrozen(childValue);
+  if (childIsFrozen && !targetIsSet) {
+    return;
+  }
+  if (childValue === targetObject)
+    die(5);
+  if (isDraft(childValue)) {
+    const path = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
+    const res = finalize(rootScope, childValue, path);
+    set(targetObject, prop, res);
+    if (isDraft(res)) {
+      rootScope.canAutoFreeze_ = false;
+    } else
+      return;
+  } else if (targetIsSet) {
+    targetObject.add(childValue);
+  }
+  if (isDraftable(childValue) && !childIsFrozen) {
+    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+      return;
+    }
+    if (parentState && parentState.base_ && parentState.base_[prop] === childValue && childIsFrozen) {
+      return;
+    }
+    finalize(rootScope, childValue);
+    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop)))
+      maybeFreeze(rootScope, childValue);
+  }
+}
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+function createProxyProxy(base, parent) {
+  const isArray = Array.isArray(base);
+  const state = {
+    type_: isArray ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: parent ? parent.scope_ : getCurrentScope(),
+    // True for both shallow and deep changes.
+    modified_: false,
+    // Used during finalization.
+    finalized_: false,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: parent,
+    // The base state.
+    base_: base,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: false
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (isArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return proxy;
+}
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    const source = latest(state);
+    if (!has(source, prop)) {
+      return readPropFromProto(state, source, prop);
+    }
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
+    }
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      return state.copy_[prop] = createProxy(value, state);
+    }
+    return value;
+  },
+  has(state, prop) {
+    return prop in latest(state);
+  },
+  ownKeys(state) {
+    return Reflect.ownKeys(latest(state));
+  },
+  set(state, prop, value) {
+    const desc = getDescriptorFromProto(latest(state), prop);
+    if (desc?.set) {
+      desc.set.call(state.draft_, value);
+      return true;
+    }
+    if (!state.modified_) {
+      const current2 = peek(latest(state), prop);
+      const currentState = current2?.[DRAFT_STATE];
+      if (currentState && currentState.base_ === value) {
+        state.copy_[prop] = value;
+        state.assigned_[prop] = false;
+        return true;
+      }
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+        return true;
+      prepareCopy(state);
+      markChanged(state);
+    }
+    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
+    (value !== void 0 || prop in state.copy_) || // special case: NaN
+    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
+      return true;
+    state.copy_[prop] = value;
+    state.assigned_[prop] = true;
+    return true;
+  },
+  deleteProperty(state, prop) {
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_[prop] = false;
+      prepareCopy(state);
+      markChanged(state);
+    } else {
+      delete state.assigned_[prop];
+    }
+    if (state.copy_) {
+      delete state.copy_[prop];
+    }
+    return true;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(state, prop) {
+    const owner = latest(state);
+    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+    if (!desc)
+      return desc;
+    return {
+      writable: true,
+      configurable: state.type_ !== 1 || prop !== "length",
+      enumerable: desc.enumerable,
+      value: owner[prop]
+    };
+  },
+  defineProperty() {
+    die(11);
+  },
+  getPrototypeOf(state) {
+    return getPrototypeOf(state.base_);
+  },
+  setPrototypeOf() {
+    die(12);
+  }
+};
+var arrayTraps = {};
+each(objectTraps, (key, fn) => {
+  arrayTraps[key] = function() {
+    arguments[0] = arguments[0][0];
+    return fn.apply(this, arguments);
+  };
+});
+arrayTraps.deleteProperty = function(state, prop) {
+  if (isNaN(parseInt(prop)))
+    die(13);
+  return arrayTraps.set.call(this, state, prop, void 0);
+};
+arrayTraps.set = function(state, prop, value) {
+  if (prop !== "length" && isNaN(parseInt(prop)))
+    die(14);
+  return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+function peek(draft, prop) {
+  const state = draft[DRAFT_STATE];
+  const source = state ? latest(state) : draft;
+  return source[prop];
+}
+function readPropFromProto(state, source, prop) {
+  const desc = getDescriptorFromProto(source, prop);
+  return desc ? `value` in desc ? desc.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    desc.get?.call(state.draft_)
+  ) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+  if (!(prop in source))
+    return void 0;
+  let proto = getPrototypeOf(source);
+  while (proto) {
+    const desc = Object.getOwnPropertyDescriptor(proto, prop);
+    if (desc)
+      return desc;
+    proto = getPrototypeOf(proto);
+  }
+  return void 0;
+}
+function markChanged(state) {
+  if (!state.modified_) {
+    state.modified_ = true;
+    if (state.parent_) {
+      markChanged(state.parent_);
+    }
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy_) {
+    state.copy_ = shallowCopy(
+      state.base_,
+      state.scope_.immer_.useStrictShallowCopy_
+    );
+  }
+}
+var Immer2 = class {
+  constructor(config) {
+    this.autoFreeze_ = true;
+    this.useStrictShallowCopy_ = false;
+    this.useStrictIteration_ = true;
+    this.produce = (base, recipe, patchListener) => {
+      if (typeof base === "function" && typeof recipe !== "function") {
+        const defaultBase = recipe;
+        recipe = base;
+        const self = this;
+        return function curriedProduce(base2 = defaultBase, ...args) {
+          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        };
+      }
+      if (typeof recipe !== "function")
+        die(6);
+      if (patchListener !== void 0 && typeof patchListener !== "function")
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(base, void 0);
+        let hasError = true;
+        try {
+          result = recipe(proxy);
+          hasError = false;
+        } finally {
+          if (hasError)
+            revokeScope(scope);
+          else
+            leaveScope(scope);
+        }
+        usePatchesInScope(scope, patchListener);
+        return processResult(result, scope);
+      } else if (!base || typeof base !== "object") {
+        result = recipe(base);
+        if (result === void 0)
+          result = base;
+        if (result === NOTHING)
+          result = void 0;
+        if (this.autoFreeze_)
+          freeze(result, true);
+        if (patchListener) {
+          const p = [];
+          const ip = [];
+          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+          patchListener(p, ip);
+        }
+        return result;
+      } else
+        die(1, base);
+    };
+    this.produceWithPatches = (base, recipe) => {
+      if (typeof base === "function") {
+        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+      }
+      let patches, inversePatches;
+      const result = this.produce(base, recipe, (p, ip) => {
+        patches = p;
+        inversePatches = ip;
+      });
+      return [result, patches, inversePatches];
+    };
+    if (typeof config?.autoFreeze === "boolean")
+      this.setAutoFreeze(config.autoFreeze);
+    if (typeof config?.useStrictShallowCopy === "boolean")
+      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+    if (typeof config?.useStrictIteration === "boolean")
+      this.setUseStrictIteration(config.useStrictIteration);
+  }
+  createDraft(base) {
+    if (!isDraftable(base))
+      die(8);
+    if (isDraft(base))
+      base = current(base);
+    const scope = enterScope(this);
+    const proxy = createProxy(base, void 0);
+    proxy[DRAFT_STATE].isManual_ = true;
+    leaveScope(scope);
+    return proxy;
+  }
+  finishDraft(draft, patchListener) {
+    const state = draft && draft[DRAFT_STATE];
+    if (!state || !state.isManual_)
+      die(9);
+    const { scope_: scope } = state;
+    usePatchesInScope(scope, patchListener);
+    return processResult(void 0, scope);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(value) {
+    this.autoFreeze_ = value;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(value) {
+    this.useStrictShallowCopy_ = value;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(value) {
+    this.useStrictIteration_ = value;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(base, patches) {
+    let i;
+    for (i = patches.length - 1; i >= 0; i--) {
+      const patch = patches[i];
+      if (patch.path.length === 0 && patch.op === "replace") {
+        base = patch.value;
+        break;
+      }
+    }
+    if (i > -1) {
+      patches = patches.slice(i + 1);
+    }
+    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
+    }
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+function createProxy(value, parent) {
+  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent ? parent.scope_ : getCurrentScope();
+  scope.drafts_.push(draft);
+  return draft;
+}
+function current(value) {
+  if (!isDraft(value))
+    die(10, value);
+  return currentImpl(value);
+}
+function currentImpl(value) {
+  if (!isDraftable(value) || isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  let copy;
+  let strict = true;
+  if (state) {
+    if (!state.modified_)
+      return state.base_;
+    state.finalized_ = true;
+    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+    strict = state.scope_.immer_.shouldUseStrictIteration();
+  } else {
+    copy = shallowCopy(value, true);
+  }
+  each(
+    copy,
+    (key, childValue) => {
+      set(copy, key, currentImpl(childValue));
+    },
+    strict
+  );
+  if (state) {
+    state.finalized_ = false;
+  }
+  return copy;
+}
+var immer = new Immer2();
+var produce = immer.produce;
+
+// src/client/snapshot-store.ts
+function createLocalSnapshotStore(initial) {
+  let current2 = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of [...listeners]) listener();
+  };
+  return {
+    getSnapshot: () => current2,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    update(mutator) {
+      const next = produce(current2, mutator);
+      if (next !== current2) {
+        current2 = next;
+        notify();
+      }
+    },
+    set(next) {
+      current2 = next;
+      notify();
+    }
+  };
+}
+
+// src/client/settings-model.ts
+var CONNECTION_KEYS = {
+  connected: "discordStatusConnected",
+  connecting: "discordStatusConnecting",
+  disconnected: "discordStatusDisconnected",
+  "invalid-token": "discordStatusInvalidToken",
+  "intents-blocked": "discordStatusIntentsBlocked",
+  "permissions-blocked": "discordStatusPermissionsBlocked"
+};
+var HINT_KEYS = {
+  "configure-token": "discordHintConfigureToken",
+  "token-rejected": "discordHintTokenRejected",
+  "enable-intents": "discordHintEnableIntents",
+  "gateway-closed": "discordHintGatewayClosed",
+  "channel-permissions": "discordHintChannelPermissions"
+};
+function presentAdapterStatus(view) {
+  return {
+    connectionKey: CONNECTION_KEYS[view.connection],
+    ...view.hint === void 0 ? {} : { hintKey: HINT_KEYS[view.hint] },
+    actionable: view.hint !== void 0,
+    tokenConfigured: view.token !== "unconfigured"
+  };
+}
+
+// src/client/card-form.ts
+var DISCORD_ID_FIELDS = [
+  "allowedGuildIds",
+  "memberUserIds",
+  "memberRoleIds",
+  "administratorUserIds",
+  "administratorRoleIds",
+  "deniedUserIds",
+  "deniedRoleIds",
+  "hostOperatorUserIds"
+];
+var ARCHIVE_FIELD = "threadAutoArchiveMinutes";
+var LANGUAGE_FIELD = "language";
+function parseLanguage(text) {
+  return text === "auto" || text === "zh" || text === "en" ? text : void 0;
+}
+function isIdField(field) {
+  return DISCORD_ID_FIELDS.includes(field);
+}
+function isLanguageField(field) {
+  return field === LANGUAGE_FIELD;
+}
+var LANGUAGE_CHOICES = [
+  { value: "zh", label: "\u4E2D\u6587" },
+  { value: "en", label: "English" }
+];
+var ARCHIVE_CHOICES = [
+  { value: "60", label: "1 \u5C0F\u65F6" },
+  { value: "1440", label: "1 \u5929" },
+  { value: "4320", label: "3 \u5929" },
+  { value: "10080", label: "7 \u5929" }
+];
+function parseArchiveMinutes(text) {
+  const parsed = Number.parseInt(text, 10);
+  return ARCHIVE_CHOICES.some((choice) => choice.value === String(parsed)) ? parsed : void 0;
+}
+var DISCORD_SNOWFLAKE = /^\d{17,20}$/u;
+function parseIdList(text) {
+  const items = text.split(/\r?\n/u).map((item) => item.trim()).filter(Boolean);
+  const unique = [...new Set(items)];
+  return unique.every((item) => DISCORD_SNOWFLAKE.test(item)) ? unique : void 0;
+}
+var DiscordCardForm = class {
+  constructor(scope) {
+    this.scope = scope;
+    this.scope.subscribe(() => {
+      this.publish();
+    });
+  }
+  staged = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  saving = false;
+  failed = false;
+  status = void 0;
+  /**
+   * Publish the Host's sanitized status view. Edits, saves, and failures
+   * never touch it — connection state is the Host's report, not form state.
+   */
+  setStatus(view) {
+    this.status = view === void 0 ? void 0 : presentAdapterStatus(view);
+    this.publish();
+  }
+  /** Publish the card state the renderer reads through its bound selector. */
+  bind() {
+    const store = createLocalSnapshotStore(this.project());
+    this.listeners.add(() => {
+      store.set(this.project());
+    });
+    return store;
+  }
+  /** Build the edit, reset, save, and discard actions bound to this form. */
+  actions() {
+    return {
+      edit: (field, text) => {
+        this.staged.set(field, { text, clear: false });
+        this.failed = false;
+        this.publish();
+      },
+      resetField: (field) => {
+        this.staged.set(field, { text: "", clear: true });
+        this.failed = false;
+        this.publish();
+      },
+      save: () => {
+        void this.save();
+      },
+      discard: () => {
+        if (this.staged.size === 0 && !this.failed) return;
+        this.staged.clear();
+        this.failed = false;
+        this.publish();
+      }
+    };
+  }
+  project() {
+    const snapshot = this.scope.getSnapshot();
+    const plan = this.plan();
+    const fields = {};
+    for (const field of DISCORD_ID_FIELDS) {
+      fields[field] = this.fieldState(field);
+    }
+    fields[ARCHIVE_FIELD] = this.fieldState(ARCHIVE_FIELD);
+    fields[LANGUAGE_FIELD] = this.fieldState(LANGUAGE_FIELD);
+    return {
+      ...fields,
+      available: snapshot.status === "ready",
+      writable: snapshot.writable,
+      dirty: plan.length > 0,
+      invalid: plan.some((item) => item.write === void 0),
+      saving: this.saving,
+      failed: this.failed,
+      status: this.status
+    };
+  }
+  fieldState(field) {
+    const staged = this.staged.get(field);
+    if (staged === void 0) {
+      return {
+        text: this.currentText(field),
+        overridden: this.stored(field),
+        invalid: false
+      };
+    }
+    const parsed = isIdField(field) ? parseIdList(staged.text) : isLanguageField(field) ? parseLanguage(staged.text) : parseArchiveMinutes(staged.text);
+    return {
+      text: staged.text,
+      overridden: parsed !== void 0,
+      invalid: parsed === void 0
+    };
+  }
+  currentText(field) {
+    const section = this.snapshot().value;
+    const value = section?.[field];
+    if (Array.isArray(value)) return value.join("\n");
+    if (typeof value === "string") return value;
+    if (typeof value === "number") return String(value);
+    return "";
+  }
+  snapshot() {
+    return this.scope.getSnapshot();
+  }
+  userLayer() {
+    return this.snapshot().user;
+  }
+  stored(field) {
+    const user = this.userLayer();
+    return user !== void 0 && Object.hasOwn(user, field);
+  }
+  plan() {
+    const plan = [];
+    for (const [field, staged] of this.staged) {
+      if (staged.clear) {
+        if (this.stored(field)) plan.push({ field, write: () => this.clear(field) });
+        continue;
+      }
+      if (isIdField(field)) {
+        const parsed2 = parseIdList(staged.text);
+        if (parsed2 === void 0) plan.push({ field, write: void 0 });
+        else plan.push({ field, write: () => this.store(field, parsed2) });
+        continue;
+      }
+      if (isLanguageField(field)) {
+        const language = parseLanguage(staged.text);
+        if (language === void 0) plan.push({ field, write: void 0 });
+        else plan.push({ field, write: () => this.store(field, language) });
+        continue;
+      }
+      const parsed = parseArchiveMinutes(staged.text);
+      if (parsed === void 0) plan.push({ field, write: void 0 });
+      else plan.push({ field, write: () => this.store(field, parsed) });
+    }
+    return plan;
+  }
+  async clear(field) {
+    await this.scope.unset(field);
+    return !this.stored(field);
+  }
+  async store(field, value) {
+    await this.scope.set(field, value);
+    return this.userLayer()?.[field] !== void 0;
+  }
+  async save() {
+    const plan = this.plan();
+    const writes = plan.flatMap((item) => item.write === void 0 ? [] : [item.write]);
+    if (plan.length === 0 || this.saving || writes.length !== plan.length) return;
+    this.saving = true;
+    this.failed = false;
+    this.publish();
+    let landed = true;
+    for (const write of writes) {
+      landed = await write().catch(() => false) && landed;
+    }
+    if (landed) this.staged.clear();
+    this.saving = false;
+    this.failed = !landed;
+    this.publish();
+  }
+  publish() {
+    for (const listener of this.listeners) listener();
+  }
+};
+
+// src/client/card-controller.ts
+var DiscordCardController = class {
+  form;
+  management;
+  constructor(scope) {
+    this.form = new DiscordCardForm(scope);
+  }
+  /** Attach the token write/connect path once the RPC face is known. */
+  setManagement(management) {
+    this.management = management;
+  }
+  /** Publish the Host's sanitized connection status onto the card. */
+  setStatus(view) {
+    this.form.setStatus(view);
+  }
+  /** Build the face the registration's inject factory returns per entry. */
+  face() {
+    return {
+      ...this.form.actions(),
+      hooks: {
+        discordCard: this.form.bind()
+      },
+      ...this.management === void 0 ? {} : { management: this.management }
+    };
+  }
+};
+
+// src/client/nav-icon.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var MARK_PATH = "M20.317 4.3698a19.7913 19.7913 0 00-4.8851-1.5152.0741.0741 0 00-.0785.0371c-.211.3753-.4447.8648-.6083 1.2495-1.8447-.2762-3.68-.2762-5.4868 0-.1636-.3933-.4058-.8742-.6177-1.2495a.077.077 0 00-.0785-.037 19.7363 19.7363 0 00-4.8852 1.515.0699.0699 0 00-.0321.0277C.5334 9.0458-.319 13.5799.0992 18.0578a.0824.0824 0 00.0312.0561c2.0528 1.5076 4.0413 2.4228 5.9929 3.0294a.0777.0777 0 00.0842-.0276c.4616-.6304.8731-1.2952 1.226-1.9942a.076.076 0 00-.0416-.1057c-.6528-.2476-1.2743-.5495-1.8722-.8923a.077.077 0 01-.0076-.1277c.1258-.0943.2517-.1923.3718-.2914a.0743.0743 0 01.0776-.0105c3.9278 1.7933 8.18 1.7933 12.0614 0a.0739.0739 0 01.0785.0095c.1202.099.246.1981.3728.2924a.077.077 0 01-.0066.1276 12.2986 12.2986 0 01-1.873.8914.0766.0766 0 00-.0407.1067c.3604.698.7719 1.3628 1.225 1.9932a.076.076 0 00.0842.0286c1.961-.6067 3.9495-1.5219 6.0023-3.0294a.077.077 0 00.0313-.0552c.5004-5.177-.8382-9.6739-3.5485-13.6604a.061.061 0 00-.0312-.0286zM8.02 15.3312c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9555-2.4189 2.157-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.9555 2.4189-2.1569 2.4189zm7.9748 0c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9554-2.4189 2.1569-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.946 2.4189-2.1568 2.4189Z";
+function DiscordMark({ size = 16 }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("svg", { viewBox: "0 0 24 24", width: size, height: size, fill: "currentColor", "aria-hidden": "true", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: MARK_PATH }) });
+}
+function markElement(size) {
+  const ns = "http://www.w3.org/2000/svg";
+  const svg = document.createElementNS(ns, "svg");
+  svg.setAttribute("viewBox", "0 0 24 24");
+  svg.setAttribute("width", String(size));
+  svg.setAttribute("height", String(size));
+  svg.setAttribute("fill", "currentColor");
+  svg.setAttribute("aria-hidden", "true");
+  svg.setAttribute("data-discord-mark", "true");
+  const path = document.createElementNS(ns, "path");
+  path.setAttribute("d", MARK_PATH);
+  svg.appendChild(path);
+  return svg;
+}
+function sweepNavIcons() {
+  const cells = document.querySelectorAll("button");
+  cells.forEach((cell) => {
+    const label = cell.querySelector('[class*="navLabel"]');
+    if (label === null || label.textContent !== "Discord") return;
+    const svg = cell.querySelector("svg");
+    if (svg === null || svg.getAttribute("data-discord-mark") === "true") return;
+    const replacement = markElement(16);
+    const hostClass = svg.getAttribute("class");
+    if (hostClass !== null) replacement.setAttribute("class", hostClass);
+    svg.replaceWith(replacement);
+  });
+}
+function installDiscordNavIcon() {
+  if (typeof document === "undefined" || typeof MutationObserver === "undefined") {
+    return () => {
+    };
+  }
+  let scheduled = false;
+  const sweepScheduled = () => {
+    if (scheduled) return;
+    scheduled = true;
+    requestAnimationFrame(() => {
+      scheduled = false;
+      sweepNavIcons();
+    });
+  };
+  const observer = new MutationObserver(sweepScheduled);
+  observer.observe(document.body, { childList: true, subtree: true });
+  sweepNavIcons();
+  return () => {
+    observer.disconnect();
+  };
+}
+
+// src/client/DiscordSettingsCard.tsx
+var import_react2 = require("react");
+
+// src/client/fields.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function SelectField(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { "data-dsh-discord-field": "", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { "data-dsh-discord-field-head": "", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("label", { htmlFor: props.id, children: props.label }),
+      props.overridden ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { "data-dsh-discord-badges": "", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { "data-dsh-discord-badge": "overridden", children: props.overriddenLabel }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "button",
+          {
+            type: "button",
+            disabled: props.disabled,
+            onClick: props.onReset,
+            children: props.resetLabel
+          }
+        )
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      "select",
+      {
+        id: props.id,
+        "aria-invalid": props.invalid,
+        value: props.text,
+        disabled: props.disabled,
+        onChange: (event) => {
+          props.onEdit(event.currentTarget.value);
+        },
+        children: props.options.map((option) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("option", { value: option.value, children: option.label }, option.value))
+      }
+    ),
+    (props.invalid || props.hint !== "") && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { "data-dsh-discord-field-note": props.invalid ? "invalid" : "hint", children: props.invalid ? props.invalidLabel : props.hint })
+  ] });
+}
+function ValueField(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { "data-dsh-discord-field": "", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { "data-dsh-discord-field-head": "", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("label", { htmlFor: props.id, children: props.label }),
+      props.overridden ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { "data-dsh-discord-badges": "", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { "data-dsh-discord-badge": "overridden", children: props.overriddenLabel }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "button",
+          {
+            type: "button",
+            disabled: props.disabled,
+            onClick: props.onReset,
+            children: props.resetLabel
+          }
+        )
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      "textarea",
+      {
+        id: props.id,
+        rows: 3,
+        "aria-invalid": props.invalid,
+        value: props.text,
+        disabled: props.disabled,
+        onInput: (event) => {
+          props.onEdit(event.currentTarget.value);
+        }
+      }
+    ),
+    (props.invalid || props.hint !== "") && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { "data-dsh-discord-field-note": props.invalid ? "invalid" : "hint", children: props.invalid ? props.invalidLabel : props.hint })
+  ] });
+}
+
+// src/client/PluginCard.tsx
+var import_react = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function PluginCard(props) {
+  const [open, setOpen] = (0, import_react.useState)(true);
+  const { state } = props;
+  if (!state.available) return null;
+  const blocked = !state.dirty || state.invalid || state.saving;
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { "data-dsh-discord-card": open ? "open" : "closed", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+      "button",
+      {
+        type: "button",
+        "aria-expanded": open,
+        "aria-label": `${props.copy[open ? "collapse" : "expand"]}: ${props.title}`,
+        onClick: () => {
+          setOpen(!open);
+        },
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { "data-dsh-discord-card-head": "", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { "data-dsh-discord-card-title": "", children: [
+              props.icon,
+              props.title
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { "data-dsh-discord-card-description": "", children: props.description })
+          ] }),
+          state.dirty ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { "data-dsh-discord-badge": "unsaved", children: props.copy.unsaved }) : null
+        ]
+      }
+    ),
+    open ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { "data-dsh-discord-card-body": "", children: [
+      !state.writable ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { role: "status", children: props.copy.readOnly }) : null,
+      props.children,
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { "data-dsh-discord-card-footer": "", children: [
+        state.failed ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { role: "status", children: props.copy.saveFailed }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+          "button",
+          {
+            type: "button",
+            disabled: !state.dirty || state.saving,
+            onClick: props.onDiscard,
+            children: props.copy.discard
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+          "button",
+          {
+            type: "button",
+            disabled: blocked,
+            onClick: props.onSave,
+            children: props.copy[state.saving ? "saving" : "save"]
+          }
+        )
+      ] })
+    ] }) : null
+  ] });
+}
+
+// src/client/DiscordSettingsCard.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var STATUS_DOT_COLOR = {
+  discordStatusConnected: "#23a55a",
+  discordStatusConnecting: "#f0b232",
+  discordStatusDisconnected: "#f23f43",
+  discordStatusInvalidToken: "#f23f43",
+  discordStatusIntentsBlocked: "#f23f43",
+  discordStatusPermissionsBlocked: "#f23f43"
+};
+var CARD_CSS = `
+[data-dsh-discord-card] { display: flex; flex-direction: column; gap: 24px; padding: 4px 2px 0; }
+[data-dsh-discord-card-head] { display: flex; flex-direction: column; gap: 2px; text-align: left; }
+[data-dsh-discord-card-title] { font-size: 14px; font-weight: 600; display: inline-flex; align-items: center; gap: 8px; }
+[data-dsh-discord-card-title] svg { opacity: .85; }
+[data-dsh-discord-card-description] { font-size: 12px; opacity: .55; }
+button[aria-expanded] { all: unset; cursor: pointer; display: block; width: 100%; box-sizing: border-box; }
+button[aria-expanded]:focus-visible { outline: 2px solid rgba(88, 101, 242, .8); border-radius: 8px; }
+[data-dsh-discord-badge] { display: inline-block; font-size: 11px; line-height: 18px; padding: 0 8px; border-radius: 999px; }
+[data-dsh-discord-badge="unsaved"] { background: rgba(250, 204, 21, .16); color: #facc15; }
+[data-dsh-discord-status] { display: flex; align-items: center; gap: 8px; font-size: 13px; }
+[data-dsh-discord-status-dot] { width: 10px; height: 10px; border-radius: 50%; flex: none; box-shadow: 0 0 6px currentColor; }
+[data-dsh-discord-field] { display: flex; flex-direction: column; gap: 6px; }
+[data-dsh-discord-field-help] + [data-dsh-discord-field], [data-dsh-discord-token] { margin-top: 8px; }
+[data-dsh-discord-field-head] { display: flex; align-items: center; gap: 8px; }
+[data-dsh-discord-field-head] label { font-size: 13px; font-weight: 500; }
+[data-dsh-discord-badges] { display: inline-flex; align-items: center; gap: 6px; margin-left: auto; }
+[data-dsh-discord-badge="overridden"] { background: rgba(250, 204, 21, .16); color: #facc15; }
+[data-dsh-discord-field-head] button { all: unset; cursor: pointer; font-size: 12px; padding: 1px 8px; border-radius: 6px; background: rgba(127, 127, 127, .18); }
+[data-dsh-discord-field-head] button:hover { background: rgba(127, 127, 127, .3); }
+[data-dsh-discord-field] textarea, [data-dsh-discord-field] select {
+  width: 100%; box-sizing: border-box; color: inherit; font: inherit; font-size: 13px;
+  background: rgba(127, 127, 127, .12); border: 1px solid rgba(127, 127, 127, .28);
+  border-radius: 8px; padding: 8px 10px; resize: vertical;
+}
+[data-dsh-discord-field] textarea:focus-visible, [data-dsh-discord-field] select:focus-visible {
+  outline: none; border-color: rgba(88, 101, 242, .9);
+}
+[data-dsh-discord-field] textarea[aria-invalid="true"], [data-dsh-discord-field] select[aria-invalid="true"] {
+  border-color: rgba(242, 63, 67, .8);
+}
+[data-dsh-discord-field-note] { margin: 0; font-size: 12px; opacity: .55; }
+[data-dsh-discord-field-note="invalid"] { opacity: 1; color: #f23f43; }
+[data-dsh-discord-field-help] { margin: -2px 0 0; font-size: 12px; opacity: .55; line-height: 1.6; }
+[data-dsh-discord-disconnect] { all: unset; cursor: pointer; margin-left: auto; font-size: 12px; padding: 2px 10px; border-radius: 6px; background: rgba(127, 127, 127, .18); }
+[data-dsh-discord-disconnect]:hover { background: rgba(242, 63, 67, .18); color: #f23f43; }
+[data-dsh-discord-token] { display: flex; flex-direction: column; gap: 8px; padding: 14px; border: 1px solid rgba(127, 127, 127, .28); border-radius: 10px; }
+[data-dsh-discord-token-row] { display: flex; gap: 10px; }
+[data-dsh-discord-token-row] input {
+  flex: 1; min-width: 0; box-sizing: border-box; color: inherit; font: inherit; font-size: 13px;
+  background: rgba(127, 127, 127, .12); border: 1px solid rgba(127, 127, 127, .28); border-radius: 8px; padding: 8px 10px;
+}
+[data-dsh-discord-token-row] input:focus-visible { outline: none; border-color: rgba(88, 101, 242, .9); }
+[data-dsh-discord-token-row] button { all: unset; cursor: pointer; font-size: 13px; padding: 7px 16px; border-radius: 8px; background: rgba(88, 101, 242, .9); color: #fff; white-space: nowrap; }
+[data-dsh-discord-token-row] button:disabled { opacity: .45; cursor: default; }
+[data-dsh-discord-token-error] { margin: 0; font-size: 12px; color: #f23f43; }
+[data-dsh-discord-card-footer] { display: flex; justify-content: flex-end; gap: 10px; margin-top: 4px; }
+[data-dsh-discord-card-footer] button { all: unset; cursor: pointer; font-size: 13px; padding: 6px 16px; border-radius: 8px; }
+[data-dsh-discord-card-footer] button[type="button"]:first-child { background: rgba(127, 127, 127, .18); }
+[data-dsh-discord-card-footer] button:not(:disabled) { background: rgba(88, 101, 242, .9); color: #fff; }
+[data-dsh-discord-card-footer] button[type="button"]:first-child:not(:disabled) { background: rgba(127, 127, 127, .18); color: inherit; }
+[data-dsh-discord-card-footer] button:disabled { opacity: .4; cursor: default; }
+[data-dsh-discord-card-footer] button:not(:disabled):hover { filter: brightness(1.12); }
+`;
+function TokenSetup(props) {
+  const { t } = props;
+  const [token, setToken] = (0, import_react2.useState)("");
+  const [connecting, setConnecting] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)("");
+  const connectionKey = props.connectionKey;
+  const visible = connectionKey === void 0 || connectionKey === "discordStatusDisconnected" || connectionKey === "discordStatusInvalidToken" || connectionKey === "discordStatusIntentsBlocked" || connectionKey === "discordStatusPermissionsBlocked";
+  if (!visible) return null;
+  const submit = () => {
+    if (props.management === void 0 || connecting) return;
+    const value = token.trim();
+    setConnecting(true);
+    setError("");
+    const write = value === "" ? Promise.resolve() : props.management.setToken(value).then(() => {
+      setToken("");
+    });
+    write.then(() => {
+      props.management?.connect();
+      props.management?.refresh();
+      setConnecting(false);
+    }, (cause) => {
+      setError(cause instanceof Error ? cause.message : String(cause));
+      setConnecting(false);
+    });
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { "data-dsh-discord-token": "", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { "data-dsh-discord-field-head": "", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("label", { htmlFor: "plugin-config-discord-token", children: t("discordTokenLabel") }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { "data-dsh-discord-token-row": "", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        "input",
+        {
+          id: "plugin-config-discord-token",
+          type: "password",
+          autoComplete: "off",
+          placeholder: props.tokenConfigured ? t("discordTokenSaved") : t("discordTokenPlaceholder"),
+          value: token,
+          disabled: connecting,
+          onChange: (event) => {
+            setToken(event.currentTarget.value);
+          },
+          onKeyDown: (event) => {
+            if (event.key === "Enter") submit();
+          }
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("button", { type: "button", disabled: connecting || !props.tokenConfigured && token.trim() === "", onClick: submit, children: connecting ? t("discordTokenConnecting") : t("discordTokenConnect") })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { "data-dsh-discord-field-help": "", children: props.tokenConfigured ? t("discordTokenReconnectHint") : t("discordTokenHelp") }),
+    error !== "" && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { "data-dsh-discord-token-error": "", children: error })
+  ] });
+}
+function DiscordSettingsCard(props) {
+  const { t } = props;
+  const state = props.useDiscordCard((snapshot) => snapshot);
+  if (!state.available) return null;
+  const copy = {
+    expand: t("expand"),
+    collapse: t("collapse"),
+    unsaved: t("unsaved"),
+    readOnly: t("readOnly"),
+    saveFailed: t("saveFailed"),
+    discard: t("discard"),
+    save: t("save"),
+    saving: t("saving")
+  };
+  const disabled = !state.writable;
+  const languageChoices = [
+    { value: "auto", label: t("discordLanguageAuto") },
+    ...LANGUAGE_CHOICES
+  ];
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+    PluginCard,
+    {
+      copy,
+      icon: DiscordMark({}),
+      title: t("discordTitle"),
+      description: t("discordDescription"),
+      state,
+      onSave: props.save,
+      onDiscard: props.discard,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("style", { children: CARD_CSS }),
+        state.status !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("p", { "data-dsh-discord-status": "", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            "span",
+            {
+              "data-dsh-discord-status-dot": "",
+              style: { background: STATUS_DOT_COLOR[state.status.connectionKey] ?? "#f23f43", color: STATUS_DOT_COLOR[state.status.connectionKey] ?? "#f23f43" }
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("span", { children: [
+            t(state.status.connectionKey),
+            state.status.hintKey !== void 0 ? ` \u2014 ${t(state.status.hintKey)}` : ""
+          ] }),
+          (state.status.connectionKey === "discordStatusConnected" || state.status.connectionKey === "discordStatusConnecting") && props.management !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            "button",
+            {
+              type: "button",
+              "data-dsh-discord-disconnect": "",
+              onClick: () => {
+                props.management?.disconnect();
+                props.management?.refresh();
+              },
+              children: t("discordDisconnect")
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TokenSetup, { management: props.management, connectionKey: state.status?.connectionKey, hintKey: state.status?.hintKey, tokenConfigured: state.status?.tokenConfigured ?? false, t }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          ValueField,
+          {
+            id: "plugin-config-discord-allowedGuildIds",
+            label: t("discordAllowedGuildIds"),
+            hint: "",
+            overriddenLabel: t("overridden"),
+            resetLabel: t("reset"),
+            invalidLabel: t("discordInvalidIds"),
+            disabled,
+            ...state.allowedGuildIds,
+            onEdit: (text) => {
+              props.edit("allowedGuildIds", text);
+            },
+            onReset: () => {
+              props.resetField("allowedGuildIds");
+            }
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { "data-dsh-discord-field-help": "", children: t("discordGuildIdHelp") }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          SelectField,
+          {
+            id: `plugin-config-discord-${ARCHIVE_FIELD}`,
+            label: t("discordThreadAutoArchive"),
+            hint: t("discordThreadAutoArchiveHint"),
+            overriddenLabel: t("overridden"),
+            resetLabel: t("reset"),
+            invalidLabel: t("discordInvalidArchive"),
+            disabled,
+            options: ARCHIVE_CHOICES,
+            ...state[ARCHIVE_FIELD],
+            onEdit: (text) => {
+              props.edit(ARCHIVE_FIELD, text);
+            },
+            onReset: () => {
+              props.resetField(ARCHIVE_FIELD);
+            }
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          SelectField,
+          {
+            id: `plugin-config-discord-${LANGUAGE_FIELD}`,
+            label: t("discordLanguage"),
+            hint: t("discordLanguageHint"),
+            overriddenLabel: t("overridden"),
+            resetLabel: t("reset"),
+            invalidLabel: t("discordInvalidLanguage"),
+            disabled,
+            options: languageChoices,
+            ...state[LANGUAGE_FIELD],
+            onEdit: (text) => {
+              props.edit(LANGUAGE_FIELD, text);
+            },
+            onReset: () => {
+              props.resetField(LANGUAGE_FIELD);
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/client/index.ts
+var name = "dsh-discord-client";
+var inject = ["settingsScope", "slots", "connection", "locale"];
+var STATUS_POLL_MS = 3e4;
+function isStatusView(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate["token"] === "string" && typeof candidate["connection"] === "string";
+}
+function apply(ctx) {
+  const scope = ctx.settingsScope.bind({ namespace: DISCORD_SETTINGS_NAMESPACE });
+  const controller = new DiscordCardController(scope);
+  ctx.locale.register("dsh-discord", {
+    en: DISCORD_CARD_LOCALE_EN,
+    zh: DISCORD_CARD_LOCALE_ZH
+  });
+  ctx.slots.inject("settings.section", () => ctx.slots.register({
+    name: "settings.section",
+    id: "discord",
+    order: 100,
+    label: "Discord",
+    locale: "dsh-discord",
+    registrant: name,
+    inject: () => controller.face()
+  }, DiscordSettingsCard));
+  ctx.effect(() => installDiscordNavIcon(), "discord nav icon shim");
+  const call = ctx.connection?.rpc?.call;
+  if (typeof call !== "function") return;
+  controller.setManagement({
+    setToken: (value) => Promise.resolve(call(DISCORD_RPC_CHANNEL, "credentials.set", { value }, void 0)).then((answer) => {
+      if (typeof answer === "object" && answer !== null && "ok" in answer && answer.ok) return;
+      const message = typeof answer === "object" && answer !== null && "error" in answer ? answer.error?.message ?? "The Host rejected the token." : "The Host rejected the token.";
+      throw new TypeError(message);
+    }),
+    connect: () => {
+      void call(DISCORD_RPC_CHANNEL, "adapter.connect", {}, void 0);
+    },
+    disconnect: () => {
+      void call(DISCORD_RPC_CHANNEL, "adapter.disconnect", {}, void 0);
+    },
+    // Immediate feedback for connect/disconnect clicks: the handshake takes
+    // a moment, so poll twice — once for the offline/starting state and once
+    // after the gateway should have landed on READY or a terminal close.
+    refresh: () => {
+      setTimeout(poll, 600);
+      setTimeout(poll, 2500);
+    }
+  });
+  const poll = () => {
+    void call(DISCORD_RPC_CHANNEL, STATUS_ENDPOINT, {}, void 0).then((answer) => {
+      if (typeof answer !== "object" || answer === null || !("ok" in answer)) return;
+      const envelope = answer;
+      controller.setStatus(envelope.ok && isStatusView(envelope.value) ? envelope.value : void 0);
+    }).catch(() => {
+      controller.setStatus(void 0);
+    });
+  };
+  poll();
+  const timer = setInterval(poll, STATUS_POLL_MS);
+  ctx.effect(() => () => {
+    clearInterval(timer);
+  }, "discord status poll");
+}
+var DISCORD_CARD_LOCALE_EN = {
+  discordTitle: "Discord",
+  discordDescription: "Bind channels to Workspaces and authorize who may use the bot.",
+  discordAllowedGuildIds: "Allowed servers",
+  discordGuildIdHelp: 'How to get it: enable Developer Mode in Discord (User Settings \u2192 Advanced), then right-click the target server and choose "Copy Server ID". One ID per line.',
+  discordTokenLabel: "Bot Token",
+  discordTokenPlaceholder: "Paste the bot token",
+  discordTokenConnect: "Connect",
+  discordTokenConnecting: "Connecting\u2026",
+  discordTokenHelp: "From the Discord Developer Portal \u2192 your application \u2192 Bot \u2192 Reset Token. Stored in the Host credential service; never written to settings or logs.",
+  discordDisconnect: "Disconnect",
+  discordTokenSaved: "Saved token \u2014 leave empty to reconnect",
+  discordTokenReconnectHint: "The token is stored in the Host credential service. Leave empty to reconnect, or paste a new one to replace it.",
+  discordThreadAutoArchive: "Task Thread Auto-archive",
+  discordThreadAutoArchiveHint: "Idle task threads archive automatically",
+  discordLanguage: "Bot Language",
+  discordLanguageHint: "Language of bot-visible messages",
+  discordLanguageAuto: "Follow DSH language",
+  discordInvalidLanguage: "Unsupported language",
+  discordInvalidIds: "IDs must be 17\u201320 digit snowflakes, one per line",
+  discordInvalidArchive: "Unsupported archive duration",
+  discordStatusConnected: "Connected",
+  discordStatusConnecting: "Connecting\u2026",
+  discordStatusDisconnected: "Disconnected",
+  discordStatusInvalidToken: "Token rejected",
+  discordStatusIntentsBlocked: "Gateway intents blocked",
+  discordStatusPermissionsBlocked: "Missing channel permissions",
+  discordHintConfigureToken: "Configure the bot token in credentials",
+  discordHintTokenRejected: "Discord rejected the token \u2014 update it",
+  discordHintEnableIntents: "Enable privileged intents in the Developer Portal",
+  discordHintGatewayClosed: "Gateway closed unexpectedly",
+  discordHintChannelPermissions: "The bot lacks permissions in this channel",
+  reset: "Reset",
+  expand: "Expand",
+  collapse: "Collapse",
+  unsaved: "Unsaved changes",
+  readOnly: "Read-only",
+  saveFailed: "Save failed",
+  discard: "Discard",
+  save: "Save",
+  saving: "Saving\u2026",
+  overridden: "Overridden"
+};
+var DISCORD_CARD_LOCALE_ZH = {
+  discordTitle: "Discord",
+  discordDescription: "\u5C06\u9891\u9053\u7ED1\u5B9A\u5230\u5DE5\u4F5C\u533A\uFF0C\u5E76\u6388\u6743\u53EF\u4F7F\u7528\u673A\u5668\u4EBA\u7684\u6210\u5458\u3002",
+  discordAllowedGuildIds: "\u5141\u8BB8\u7684\u670D\u52A1\u5668",
+  discordGuildIdHelp: "\u83B7\u53D6\u65B9\u5F0F\uFF1A\u5728 Discord \u4E2D\u5F00\u542F\u5F00\u53D1\u8005\u6A21\u5F0F\uFF08\u7528\u6237\u8BBE\u7F6E \u2192 \u9AD8\u7EA7\u8BBE\u7F6E\uFF09\uFF0C\u7136\u540E\u53F3\u952E\u70B9\u51FB\u76EE\u6807\u670D\u52A1\u5668 \u2192\u300C\u590D\u5236\u670D\u52A1\u5668 ID\u300D\u3002\u6BCF\u884C\u586B\u4E00\u4E2A ID\u3002",
+  discordTokenLabel: "Bot Token",
+  discordTokenPlaceholder: "\u7C98\u8D34 Bot Token",
+  discordTokenConnect: "\u8FDE\u63A5",
+  discordTokenConnecting: "\u8FDE\u63A5\u4E2D\u2026",
+  discordTokenHelp: "\u6765\u81EA Discord \u5F00\u53D1\u8005\u95E8\u6237 \u2192 \u4F60\u7684\u5E94\u7528 \u2192 Bot \u2192 Reset Token\u3002\u7531 Host \u51ED\u636E\u670D\u52A1\u52A0\u5BC6\u4FDD\u5B58\uFF0C\u4E0D\u4F1A\u5199\u5165\u8BBE\u7F6E\u6216\u65E5\u5FD7\u3002",
+  discordDisconnect: "\u65AD\u5F00\u8FDE\u63A5",
+  discordTokenSaved: "\u5DF2\u4FDD\u5B58\u7684 Token \u2014 \u7559\u7A7A\u76F4\u63A5\u91CD\u65B0\u8FDE\u63A5",
+  discordTokenReconnectHint: "Token \u5DF2\u4FDD\u5B58\u5728 Host \u51ED\u636E\u670D\u52A1\u4E2D\u3002\u7559\u7A7A\u76F4\u63A5\u91CD\u8FDE\uFF0C\u6216\u7C98\u8D34\u65B0 Token \u8FDB\u884C\u66FF\u6362\u3002",
+  discordThreadAutoArchive: "\u4EFB\u52A1\u7EBF\u7A0B\u81EA\u52A8\u5F52\u6863",
+  discordThreadAutoArchiveHint: "\u95F2\u7F6E\u7684\u4EFB\u52A1\u7EBF\u7A0B\u5230\u671F\u540E\u81EA\u52A8\u5F52\u6863",
+  discordLanguage: "Bot \u8BED\u8A00",
+  discordLanguageHint: "\u673A\u5668\u4EBA\u53EF\u89C1\u6D88\u606F\u4F7F\u7528\u7684\u8BED\u8A00",
+  discordLanguageAuto: "\u8DDF\u968F DSH \u8BED\u8A00",
+  discordInvalidLanguage: "\u4E0D\u652F\u6301\u7684\u8BED\u8A00",
+  discordInvalidIds: "ID \u5FC5\u987B\u662F 17\u201320 \u4F4D\u96EA\u82B1\u6570\u5B57\uFF0C\u6BCF\u884C\u4E00\u4E2A",
+  discordInvalidArchive: "\u4E0D\u652F\u6301\u7684\u5F52\u6863\u65F6\u957F",
+  discordStatusConnected: "\u5DF2\u8FDE\u63A5",
+  discordStatusConnecting: "\u8FDE\u63A5\u4E2D\u2026",
+  discordStatusDisconnected: "\u672A\u8FDE\u63A5",
+  discordStatusInvalidToken: "Token \u88AB\u62D2\u7EDD",
+  discordStatusIntentsBlocked: "Gateway intents \u88AB\u62D2",
+  discordStatusPermissionsBlocked: "\u7F3A\u5C11\u9891\u9053\u6743\u9650",
+  discordHintConfigureToken: "\u8BF7\u5728\u51ED\u636E\u4E2D\u914D\u7F6E Bot Token",
+  discordHintTokenRejected: "Discord \u62D2\u7EDD\u4E86\u8BE5 Token\uFF0C\u8BF7\u66F4\u65B0",
+  discordHintEnableIntents: "\u8BF7\u5728\u5F00\u53D1\u8005\u95E8\u6237\u5F00\u542F\u7279\u6743 intents",
+  discordHintGatewayClosed: "Gateway \u8FDE\u63A5\u5F02\u5E38\u5173\u95ED",
+  discordHintChannelPermissions: "Bot \u5728\u8BE5\u9891\u9053\u7F3A\u5C11\u6743\u9650",
+  reset: "\u91CD\u7F6E",
+  expand: "\u5C55\u5F00",
+  collapse: "\u6536\u8D77",
+  unsaved: "\u6709\u672A\u4FDD\u5B58\u4FEE\u6539",
+  readOnly: "\u53EA\u8BFB",
+  saveFailed: "\u4FDD\u5B58\u5931\u8D25",
+  discard: "\u653E\u5F03",
+  save: "\u4FDD\u5B58",
+  saving: "\u4FDD\u5B58\u4E2D\u2026",
+  overridden: "\u5DF2\u8986\u76D6"
+};
+
+    return module.exports;
+  }
+});