@kosdev-code/kos-ui-plugin 2.1.17 → 2.1.19

package/documentation-generator-Di4c9D9P.js

@@ -0,0 +1,2337 @@
+var X = Object.defineProperty;
+var ee = (n, e, t) => e in n ? X(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var v = (n, e, t) => (ee(n, typeof e != "symbol" ? e + "" : e, t), t);
+import { z as V } from "zod";
+function te(n, e) {
+  for (var t = 0; t < e.length; t++) {
+    const i = e[t];
+    if (typeof i != "string" && !Array.isArray(i)) {
+      for (const s in i)
+        if (s !== "default" && !(s in n)) {
+          const o = Object.getOwnPropertyDescriptor(i, s);
+          o && Object.defineProperty(n, s, o.get ? o : {
+            enumerable: !0,
+            get: () => i[s]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var A = {}, R = {};
+Object.defineProperty(R, "__esModule", { value: !0 });
+R.loadRemoteModule = R.setRemoteDefinitions = R.setRemoteUrlResolver = void 0;
+let T, j;
+const O = /* @__PURE__ */ new Map(), K = /* @__PURE__ */ new Map();
+let B = !1;
+function ne(n) {
+  j = n;
+}
+R.setRemoteUrlResolver = ne;
+function ie(n) {
+  T = n;
+}
+R.setRemoteDefinitions = ie;
+async function se(n, e) {
+  const t = `${n}:${e}`;
+  if (O.has(t))
+    return O.get(t);
+  const o = (await (K.has(n) ? K.get(n) : await re(n)).get(e))();
+  return O.set(t, o), o;
+}
+R.loadRemoteModule = se;
+const oe = (n, e) => new Promise((t, i) => {
+  const s = document.createElement("script");
+  s.src = n, s.type = "text/javascript", s.async = !0, s.onload = () => {
+    t({
+      get: (r) => window[e].get(r),
+      init: (r) => {
+        try {
+          window[e].init(r);
+        } catch (a) {
+          console.error(`Failed to initialize remote ${e}`, a), i(a);
+        }
+      }
+    });
+  }, s.onerror = () => i(new Error(`Remote ${e} not found`)), document.head.appendChild(s);
+});
+async function re(n) {
+  if (!j && !T)
+    throw new Error("Call setRemoteDefinitions or setRemoteUrlResolver to allow Dynamic Federation to find the remote apps correctly.");
+  B || (B = !0, await __webpack_init_sharing__("default"));
+  const e = T ? T[n] : await j(n);
+  let t = e;
+  !e.endsWith(".mjs") && !e.endsWith(".js") && (t = `${e}${e.endsWith("/") ? "" : "/"}remoteEntry.js`);
+  const i = await oe(t, n);
+  return await i.init(__webpack_share_scopes__.default), K.set(n, i), i;
+}
+(function(n) {
+  Object.defineProperty(n, "__esModule", { value: !0 }), n.setRemoteUrlResolver = n.setRemoteDefinitions = n.loadRemoteModule = void 0;
+  var e = R;
+  Object.defineProperty(n, "loadRemoteModule", { enumerable: !0, get: function() {
+    return e.loadRemoteModule;
+  } }), Object.defineProperty(n, "setRemoteDefinitions", { enumerable: !0, get: function() {
+    return e.setRemoteDefinitions;
+  } }), Object.defineProperty(n, "setRemoteUrlResolver", { enumerable: !0, get: function() {
+    return e.setRemoteUrlResolver;
+  } });
+})(A);
+const Be = /* @__PURE__ */ te({
+  __proto__: null
+}, [A]);
+function ae(n, e, t = !1) {
+  return !n || Object.keys(n).length === 0 ? null : t ? e && n[e] ? n[e] : null : e && n[e] ? n[e] : Object.values(n).filter((s) => typeof s.id == "string").sort((s, o) => {
+    const r = typeof s.rank == "number" ? s.rank : 1 / 0, a = typeof o.rank == "number" ? o.rank : 1 / 0;
+    if (r === a) {
+      const c = s.id ?? "", l = o.id ?? "";
+      return c.localeCompare(l);
+    }
+    return r - a;
+  })[0] ?? null;
+}
+class ce {
+  constructor() {
+    /**
+     * Map of contribution ID to its dynamic contribution state
+     */
+    v(this, "contributions", /* @__PURE__ */ new Map());
+    /**
+     * Map of extension point to contribution IDs
+     * Allows efficient lookup of contributions by extension point
+     */
+    v(this, "extensionPointIndex", /* @__PURE__ */ new Map());
+    /**
+     * Global listeners for all state changes
+     */
+    v(this, "globalListeners", /* @__PURE__ */ new Set());
+    /**
+     * Extension point-scoped listeners
+     * Map of extension point to listeners
+     */
+    v(this, "extensionPointListeners", /* @__PURE__ */ new Map());
+    /**
+     * Current enablement context for conditional evaluation
+     */
+    v(this, "enablementContext", {
+      extensions: {},
+      contributions: {
+        controlPourDefinitions: {},
+        experiences: {}
+      },
+      context: {}
+    });
+  }
+  /**
+   * Register a contribution in the registry
+   *
+   * This is called during plugin initialization to register all contributions
+   * with their default enabled state (true).
+   *
+   * @param contributionId - Unique identifier for the contribution
+   * @param extensionPoint - Extension point this contribution belongs to
+   * @param contribution - The contribution object
+   * @internal
+   */
+  register(e, t, i) {
+    const s = {
+      ...i,
+      enabled: !0,
+      lastStateChange: Date.now()
+    };
+    this.contributions.set(e, s), this.extensionPointIndex.has(t) || this.extensionPointIndex.set(t, /* @__PURE__ */ new Set()), this.extensionPointIndex.get(t).add(e);
+  }
+  /**
+   * Update the enablement context
+   *
+   * The context is used when evaluating conditional enablement functions.
+   *
+   * @param context - New enablement context
+   * @internal
+   */
+  setContext(e) {
+    this.enablementContext = {
+      ...this.enablementContext,
+      ...e
+    };
+  }
+  /**
+   * Set enabled state for a contribution
+   *
+   * Updates the contribution's enabled state and emits a
+   * ContributionStateChangeEvent to all subscribers.
+   *
+   * @param contributionId - Unique identifier of the contribution
+   * @param enabled - New enabled state (true = enabled, false = disabled)
+   * @param reason - Optional human-readable reason for the change
+   */
+  setEnabled(e, t, i) {
+    const s = this.contributions.get(e);
+    if (!s) {
+      console.warn(
+        `ContributionRegistry.setEnabled: Contribution '${e}' not found. Ignoring.`
+      );
+      return;
+    }
+    const o = s.enabled;
+    o !== t && (s.enabled = t, s.disabledReason = t ? void 0 : i, s.lastStateChange = Date.now(), this.emitStateChange({
+      contributionId: e,
+      extensionPoint: this.findExtensionPoint(e),
+      enabled: t,
+      previousState: o,
+      reason: i,
+      timestamp: s.lastStateChange
+    }));
+  }
+  /**
+   * Get enabled state for a contribution
+   *
+   * Checks both the enabled boolean field and evaluates any
+   * enabledCondition function if present. Returns true only if
+   * both checks pass.
+   *
+   * @param contributionId - Unique identifier of the contribution
+   * @returns true if contribution is enabled, false otherwise
+   */
+  isEnabled(e) {
+    const t = this.contributions.get(e);
+    if (!t)
+      return !0;
+    if (!t.enabled)
+      return !1;
+    if (t.enabledCondition)
+      try {
+        return t.enabledCondition(this.enablementContext);
+      } catch (i) {
+        return console.error(
+          `ContributionRegistry.isEnabled: Error evaluating enabledCondition for '${e}':`,
+          i
+        ), !1;
+      }
+    return !0;
+  }
+  /**
+   * Subscribe to all contribution state changes
+   *
+   * Registers a listener that will be called whenever any contribution's
+   * enabled state changes. The listener receives a ContributionStateChangeEvent.
+   *
+   * @param listener - Callback function to handle state change events
+   * @returns Unsubscribe function to stop receiving events
+   */
+  subscribe(e) {
+    if (typeof e != "function")
+      throw new TypeError(
+        "ContributionRegistry.subscribe: listener must be a function"
+      );
+    return this.globalListeners.add(e), () => {
+      this.globalListeners.delete(e);
+    };
+  }
+  /**
+   * Subscribe to changes for a specific extension point
+   *
+   * Like subscribe(), but only emits events for contributions
+   * belonging to the specified extension point.
+   *
+   * @param extensionPoint - Extension point identifier to monitor
+   * @param listener - Callback function to handle state change events
+   * @returns Unsubscribe function to stop receiving events
+   */
+  subscribeToExtensionPoint(e, t) {
+    if (typeof t != "function")
+      throw new TypeError(
+        "ContributionRegistry.subscribeToExtensionPoint: listener must be a function"
+      );
+    return this.extensionPointListeners.has(e) || this.extensionPointListeners.set(e, /* @__PURE__ */ new Set()), this.extensionPointListeners.get(e).add(t), () => {
+      var i, s;
+      (i = this.extensionPointListeners.get(e)) == null || i.delete(t), ((s = this.extensionPointListeners.get(e)) == null ? void 0 : s.size) === 0 && this.extensionPointListeners.delete(e);
+    };
+  }
+  /**
+   * Batch update multiple contributions atomically
+   *
+   * Updates multiple contribution states in a single atomic operation.
+   * All updates succeed or all fail together. Emits one event per
+   * contribution that changed state.
+   *
+   * @param updates - Array of contribution updates to apply
+   */
+  batchUpdate(e) {
+    if (!Array.isArray(e))
+      throw new TypeError(
+        "ContributionRegistry.batchUpdate: updates must be an array"
+      );
+    const t = e.map((s) => {
+      const o = this.contributions.get(s.contributionId);
+      return o ? o.enabled === s.enabled ? null : {
+        contribution: o,
+        update: s,
+        previousState: o.enabled
+      } : (console.warn(
+        `ContributionRegistry.batchUpdate: Contribution '${s.contributionId}' not found. Skipping.`
+      ), null);
+    }), i = Date.now();
+    t.forEach((s) => {
+      if (!s)
+        return;
+      const { contribution: o, update: r } = s;
+      o.enabled = r.enabled, o.disabledReason = r.enabled ? void 0 : r.reason, o.lastStateChange = i;
+    }), t.forEach((s) => {
+      if (!s)
+        return;
+      const { update: o, previousState: r } = s;
+      this.emitStateChange({
+        contributionId: o.contributionId,
+        extensionPoint: this.findExtensionPoint(o.contributionId),
+        enabled: o.enabled,
+        previousState: r,
+        reason: o.reason,
+        timestamp: i
+      });
+    });
+  }
+  /**
+   * Get all contributions for an extension point
+   *
+   * Returns an array of DynamicContribution objects for the specified
+   * extension point. By default, only returns enabled contributions.
+   *
+   * @param extensionPoint - Extension point identifier
+   * @param includeDisabled - If true, include disabled contributions in results
+   * @returns Array of contributions for the extension point
+   */
+  getContributions(e, t = !1) {
+    const i = this.extensionPointIndex.get(e);
+    if (!i || i.size === 0)
+      return [];
+    const s = [];
+    return i.forEach((o) => {
+      const r = this.contributions.get(o);
+      r && (t || this.isEnabled(o)) && s.push(r);
+    }), s;
+  }
+  /**
+   * Find the extension point for a contribution ID
+   * @internal
+   */
+  findExtensionPoint(e) {
+    for (const [t, i] of this.extensionPointIndex.entries())
+      if (i.has(e))
+        return t;
+    return "";
+  }
+  /**
+   * Emit state change event to all relevant listeners
+   * @internal
+   */
+  emitStateChange(e) {
+    this.globalListeners.forEach((i) => {
+      try {
+        i(e);
+      } catch (s) {
+        console.error("ContributionRegistry: Error in global listener:", s);
+      }
+    });
+    const t = this.extensionPointListeners.get(e.extensionPoint);
+    t && t.forEach((i) => {
+      try {
+        i(e);
+      } catch (s) {
+        console.error(
+          `ContributionRegistry: Error in extension point listener for '${e.extensionPoint}':`,
+          s
+        );
+      }
+    });
+  }
+  /**
+   * Clear all state (useful for testing or cleanup)
+   * @internal
+   */
+  reset() {
+    this.contributions.clear(), this.extensionPointIndex.clear(), this.globalListeners.clear(), this.extensionPointListeners.clear(), this.enablementContext = {
+      extensions: {},
+      contributions: {
+        controlPourDefinitions: {},
+        experiences: {}
+      },
+      context: {}
+    };
+  }
+}
+const N = new ce(), G = [];
+function le(n) {
+  G.push(n);
+}
+function ue(n, e, t) {
+  return G.reduce(
+    (i, s) => s(i, e, t),
+    n
+  );
+}
+function de(n) {
+  var e;
+  try {
+    if ("shape" in n) {
+      const t = n, i = [];
+      for (const [s, o] of Object.entries(
+        t.shape
+      )) {
+        const r = o, a = {
+          name: s,
+          required: !r.isOptional()
+        };
+        if (r._def && r._def.description && (a.description = r._def.description), r._def) {
+          let c = r._def.typeName || "unknown";
+          c === "ZodOptional" && r._def.innerType && (c = ((e = r._def.innerType._def) == null ? void 0 : e.typeName) || "unknown"), a.type = c.replace("Zod", "").toLowerCase();
+        }
+        i.push(a);
+      }
+      return i;
+    }
+    return [];
+  } catch (t) {
+    return console.warn("Failed to extract schema field info:", t), [];
+  }
+}
+class fe {
+  constructor() {
+    v(this, "issues", []);
+  }
+  addError(e) {
+    this.issues.push({ type: "error", message: e });
+  }
+  addWarning(e) {
+    this.issues.push({ type: "warning", message: e });
+  }
+  addInfo(e) {
+    this.issues.push({ type: "info", message: e });
+  }
+  hasErrors() {
+    return this.issues.some((e) => e.type === "error");
+  }
+  hasIssues() {
+    return this.issues.length > 0;
+  }
+  getIssues() {
+    return [...this.issues];
+  }
+}
+class ge {
+  constructor() {
+    v(this, "cache", /* @__PURE__ */ new Map());
+  }
+  set(e, t) {
+    this.cache.set(e, t);
+  }
+  get(e) {
+    return this.cache.get(e) || [];
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+const U = new ge();
+function He(n) {
+  return U.get(n);
+}
+class pe {
+  constructor() {
+    v(this, "extensionPoints", /* @__PURE__ */ new Map());
+  }
+  define(e) {
+    if (this.extensionPoints.has(e.id))
+      return console.warn(`Extension point ${e.id} is already defined`), this.extensionPoints.get(e.id);
+    const t = {
+      config: e,
+      id: e.id,
+      isRegistered: !1,
+      getExtensions: (i) => i[e.id] || {},
+      register: () => {
+        if (t.isRegistered) {
+          console.warn(`Extension point ${e.id} is already registered`);
+          return;
+        }
+        const i = this.createReducer(e);
+        le(i), t.isRegistered = !0;
+      }
+    };
+    return e.schema && (t.getSchemaFieldInfo = () => de(e.schema)), this.extensionPoints.set(e.id, t), t;
+  }
+  createReducer(e) {
+    return (t, i, s) => {
+      const o = i[e.contributionKey];
+      return !o || typeof o != "object" || Object.entries(o).forEach(
+        ([r, a]) => {
+          var d, m;
+          if (!a)
+            return;
+          const c = {
+            remote: a.remote || "",
+            sectionId: a.sectionId || r,
+            experiences: s,
+            contributions: i
+          };
+          if (e.validate) {
+            const f = new fe();
+            if (e.validate(
+              a,
+              f
+            ) === "skip") {
+              U.set(r, [
+                {
+                  type: "warning",
+                  message: "Plugin marked to skip processing"
+                }
+              ]);
+              return;
+            }
+            if (f.hasIssues()) {
+              const w = f.getIssues().map((E) => ({
+                ...E,
+                message: `Extension point validation: ${E.message}`
+              }));
+              if (U.set(r, w), f.hasErrors()) {
+                console.error(
+                  `Validation failed for ${e.id} contribution "${r}":`,
+                  w.filter((E) => E.type === "error").map((E) => E.message).join(", ")
+                );
+                return;
+              }
+            } else
+              U.set(r, []);
+          }
+          const l = e.transform ? e.transform(a, c) : a;
+          t[e.id] || (t[e.id] = {});
+          const u = {
+            id: r,
+            type: e.contributionKey,
+            data: l,
+            remote: c.remote,
+            sectionId: c.sectionId
+          };
+          if (e.isRankable && typeof a.rank == "number" && (u.rank = a.rank), l && typeof l == "object" && ("component" in l && (u.component = l.component), "view" in l && (u.view = l.view), "location" in l && (u.location = l.location)), t[e.id][r] = u, N.register(r, e.id, {
+            id: r,
+            remote: c.remote,
+            sectionId: c.sectionId
+          }), e.hasView && ((d = e.relatedPoints) != null && d.view)) {
+            const f = a.experienceId, g = s == null ? void 0 : s[f];
+            g && (t[e.relatedPoints.view] || (t[e.relatedPoints.view] = {}), t[e.relatedPoints.view][r] = {
+              id: r,
+              type: `${e.contributionKey}.view`,
+              data: g,
+              remote: c.remote,
+              sectionId: c.sectionId
+            }, N.register(r, e.relatedPoints.view, {
+              id: r,
+              remote: c.remote,
+              sectionId: c.sectionId
+            }));
+          }
+          (m = e.relatedPoints) != null && m.definition && (t[e.relatedPoints.definition] || (t[e.relatedPoints.definition] = {}), t[e.relatedPoints.definition][r] = {
+            id: r,
+            type: `${e.contributionKey}.definition`,
+            data: l,
+            remote: c.remote,
+            sectionId: c.sectionId
+          }, N.register(
+            r,
+            e.relatedPoints.definition,
+            {
+              id: r,
+              remote: c.remote,
+              sectionId: c.sectionId
+            }
+          ));
+        }
+      ), t;
+    };
+  }
+  /**
+   * Get all registered extension points (for discovery/documentation)
+   */
+  getAllExtensionPoints() {
+    return Array.from(this.extensionPoints.values()).filter(
+      (e) => e.isRegistered
+    );
+  }
+  /**
+   * Get all defined extension points (registered and unregistered)
+   */
+  getAllDefinedExtensionPoints() {
+    return Array.from(this.extensionPoints.values());
+  }
+  /**
+   * Get a specific extension point definition
+   */
+  getExtensionPoint(e) {
+    return this.extensionPoints.get(e);
+  }
+  /**
+   * Check if an extension point is registered
+   */
+  hasExtensionPoint(e) {
+    return this.extensionPoints.has(e);
+  }
+  /**
+   * Get the Zod schema for an extension point
+   * Returns undefined if the extension point doesn't have a schema
+   */
+  getExtensionPointSchema(e) {
+    const t = this.extensionPoints.get(e);
+    return t == null ? void 0 : t.config.schema;
+  }
+}
+const L = new pe();
+function C() {
+  return L;
+}
+function We(n) {
+  return L.getExtensionPointSchema(n);
+}
+function me(n = {}) {
+  const {
+    experienceIdProperty: e = "experienceId",
+    flattenComponentProperties: t = !0,
+    customTransform: i
+  } = n;
+  return (s, o) => {
+    var l;
+    const r = s[e], a = r ? ((l = o.experiences) == null ? void 0 : l[r]) || {} : {};
+    let c = {
+      ...s,
+      view: a
+    };
+    return t && a && (a.component && (c.component = a.component), a.location && (c.location = a.location)), i && (c = i(s, a, o) || c), c;
+  };
+}
+function he(n) {
+  return L.define(n);
+}
+const be = {
+  $timestamp: () => Date.now(),
+  $date: () => (/* @__PURE__ */ new Date()).toISOString(),
+  $packageVersion: () => process.env.npm_package_version || "0.0.0",
+  $env: () => process.env.NODE_ENV || "development"
+};
+function ye(n) {
+  const e = {
+    id: n.id,
+    displayName: n.displayName,
+    description: n.description,
+    contributionKey: n.contributionKey,
+    hasView: n.hasView,
+    isRankable: n.isRankable,
+    relatedPoints: n.relatedPoints,
+    metadata: n.metadata ? {
+      ...n.metadata,
+      exportName: n.metadata.exportName || xe(n.id)
+    } : void 0
+  };
+  return n.schema && (e.schema = ve(n.schema, {
+    hasView: n.hasView,
+    isRankable: n.isRankable
+  })), n.validation && (e.validate = we(n.validation)), n.transform ? e.transform = Ve(n.transform) : n.hasView && (e.transform = me()), e;
+}
+function xe(n) {
+  return n.split(".").map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join("") + "Extension";
+}
+function ve(n, e) {
+  try {
+    const { z: t } = require("zod");
+    if (n.properties) {
+      const i = {};
+      i.id = t.string().min(1), i.title = t.string().min(1), i.namespace = t.string().min(1), e != null && e.hasView && (i.experienceId = t.string().min(1)), e != null && e.isRankable && (i.rank = t.number().min(0).max(1e3).optional());
+      for (const [o, r] of Object.entries(n.properties))
+        i[o] = Ee(r, t);
+      let s = t.object(i);
+      return n.additionalProperties || (s = s.strict()), s;
+    }
+    return t.any();
+  } catch (t) {
+    console.warn("Zod not available for JSON schema conversion:", t);
+    return;
+  }
+}
+function Ee(n, e) {
+  let t;
+  switch (n.type) {
+    case "string":
+      t = e.string(), n.minLength && (t = t.min(n.minLength)), n.maxLength && (t = t.max(n.maxLength)), n.pattern && (t = t.regex(new RegExp(n.pattern))), n.enum && (t = e.enum(n.enum));
+      break;
+    case "number":
+      t = e.number(), n.minimum !== void 0 && (t = t.min(n.minimum)), n.maximum !== void 0 && (t = t.max(n.maximum));
+      break;
+    case "boolean":
+      t = e.boolean();
+      break;
+    case "array":
+      t = e.array(e.any());
+      break;
+    case "object":
+      t = e.object({});
+      break;
+    default:
+      t = e.any();
+  }
+  return n.description && (t = t.describe(n.description)), n.default !== void 0 && (t = t.default(n.default)), t;
+}
+function we(n) {
+  return n.module ? Se(n.module) : (e, t) => {
+    if (!n.rules)
+      return;
+    const i = e;
+    for (const s of n.rules)
+      Pe(s, i, t);
+  };
+}
+function Pe(n, e, t) {
+  switch (n.type) {
+    case "required":
+      Ce(n, e, t);
+      break;
+    case "range":
+      $e(n, e, t);
+      break;
+    case "pattern":
+      ke(n, e, t);
+      break;
+    case "dependency":
+      Re(n, e, t);
+      break;
+    case "custom":
+      Ie(n, e, t);
+      break;
+  }
+}
+function Ce(n, e, t) {
+  n.field && !e[n.field] && t.addError(n.message || `Field '${n.field}' is required`);
+}
+function $e(n, e, t) {
+  if (n.field && typeof e[n.field] == "number") {
+    const i = e[n.field];
+    n.min !== void 0 && i < n.min && t.addError(
+      n.message || `Field '${n.field}' must be at least ${n.min}`
+    ), n.max !== void 0 && i > n.max && t.addError(
+      n.message || `Field '${n.field}' must be at most ${n.max}`
+    );
+  }
+}
+function ke(n, e, t) {
+  n.field && n.pattern && typeof e[n.field] == "string" && (new RegExp(n.pattern).test(e[n.field]) || t.addError(
+    n.message || `Field '${n.field}' does not match pattern ${n.pattern}`
+  ));
+}
+function Re(n, e, t) {
+  if (n.field && n.dependsOn && n.expression)
+    try {
+      _(n.expression, e) || t.addError(
+        n.message || `Field '${n.field}' dependency validation failed`
+      );
+    } catch (i) {
+      t.addWarning(`Failed to evaluate dependency expression: ${i}`);
+    }
+}
+function Ie(n, e, t) {
+  if (n.expression)
+    try {
+      _(n.expression, e) || t.addError(n.message || "Custom validation failed");
+    } catch (i) {
+      t.addWarning(`Failed to evaluate custom expression: ${i}`);
+    }
+}
+function Se(n) {
+  return (e, t) => {
+    console.warn(`External validation module not implemented: ${n}`), t.addWarning(
+      `External validation module not yet supported: ${n}`
+    );
+  };
+}
+function Ve(n) {
+  return n.module ? Ne(n.module) : (e, t) => {
+    const i = { ...e };
+    if (n.addFields)
+      for (const [s, o] of Object.entries(n.addFields))
+        i[s] = De(o);
+    if (n.removeFields)
+      for (const s of n.removeFields)
+        delete i[s];
+    if (n.renameFields)
+      for (const [s, o] of Object.entries(
+        n.renameFields
+      ))
+        s in i && (i[o] = i[s], delete i[s]);
+    if (n.normalizeFields)
+      for (const { field: s, operation: o } of n.normalizeFields)
+        s in i && typeof i[s] == "string" && (i[s] = Fe(
+          i[s],
+          o
+        ));
+    return i;
+  };
+}
+function Ne(n) {
+  return (e, t) => (console.warn(`External transform module not implemented: ${n}`), e);
+}
+function De(n) {
+  if (typeof n == "string" && n.startsWith("$")) {
+    const e = be[n];
+    if (e)
+      return e();
+  }
+  return n;
+}
+function Fe(n, e) {
+  switch (e) {
+    case "trim":
+      return n.trim();
+    case "lowercase":
+      return n.toLowerCase();
+    case "uppercase":
+      return n.toUpperCase();
+    case "camelCase":
+      return Te(n);
+    case "kebabCase":
+      return Ue(n);
+    default:
+      return n;
+  }
+}
+function Te(n) {
+  return n.replace(/[-_\s]+(.)?/g, (e, t) => t ? t.toUpperCase() : "").replace(/^./, (e) => e.toLowerCase());
+}
+function Ue(n) {
+  return n.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function _(n, e) {
+  try {
+    let t = n;
+    for (const [i, s] of Object.entries(e)) {
+      const o = typeof s == "string" ? `"${s}"` : String(s);
+      t = t.replace(
+        new RegExp(`\\b${i}\\b`, "g"),
+        o
+      );
+    }
+    if (t.includes("!==")) {
+      const [i, s] = t.split("!==").map((o) => o.trim());
+      return i !== s;
+    }
+    if (t.includes("===")) {
+      const [i, s] = t.split("===").map((o) => o.trim());
+      return i === s;
+    }
+    return t.includes("||") ? t.split("||").map((s) => s.trim()).some((s) => _(s, e)) : t.includes("&&") ? t.split("&&").map((s) => s.trim()).every((s) => _(s, e)) : !1;
+  } catch (t) {
+    return console.error("Expression evaluation failed:", t), !1;
+  }
+}
+const _e = (n) => (e, t) => {
+  var c;
+  const i = n[t].remote, s = n[t].section || "default", o = ((c = n[t].contributes) == null ? void 0 : c.experiences) ?? {};
+  return Object.keys(o).forEach((l) => {
+    const u = o[l];
+    e.experiences[l] = {
+      ...u,
+      remote: i,
+      sectionId: s
+    };
+  }), C().getAllExtensionPoints().forEach((l) => {
+    var m;
+    const { contributionKey: u } = l.config, d = (m = n[t].contributes) == null ? void 0 : m[u];
+    d && (e[u] || (e[u] = {}), Array.isArray(d) ? d.forEach((f) => {
+      f && f.id && (e[u][f.id] = {
+        ...f,
+        remote: i,
+        sectionId: s
+      });
+    }) : typeof d == "object" && Object.entries(d).forEach(([f, g]) => {
+      e[u][f] = {
+        ...g,
+        id: f,
+        remote: i,
+        sectionId: s
+      };
+    }));
+  }), e;
+};
+async function Ae(n) {
+  const e = n ?? window.KosPlugins.__dynamicRemotes;
+  if (window.KosPlugins.extensions) {
+    const o = window.KosPlugins.extensions;
+    return {
+      extensionPoints: o,
+      getExtensions: (r) => o[r] || [],
+      remotes: e,
+      extensions: window.KosPlugins.__extensions
+    };
+  }
+  const t = window.KosPlugins.__extensions ?? await qe(e), i = {};
+  if (t)
+    for (const o of Object.keys(t))
+      i[o] = Object.values(
+        t[o] || {}
+      );
+  return window.KosPlugins.extensions = i, { extensionPoints: i, getExtensions: (o) => i[o] || [], remotes: e, extensions: t };
+}
+const H = {
+  controlPourDefinitions: {},
+  experiences: {}
+};
+function Oe(n) {
+  return n ? Object.keys(n).reduce(_e(n), {
+    ...H
+  }) : H;
+}
+async function qe(n) {
+  if (!n)
+    return window.KosPlugins = window.KosPlugins || {}, {};
+  for (const o of Object.values(n)) {
+    try {
+      if (o.extensions && Array.isArray(o.extensions)) {
+        const r = o.extensions.filter((a) => a && typeof a == "object" && "id" in a).map((a) => ye(a));
+        if (r.length > 0) {
+          console.info(
+            `Registering ${r.length} JSON extension point(s) from ${o.remote}`
+          );
+          for (const a of r)
+            try {
+              he(a).register(), console.debug(`Registered JSON extension point: ${a.id}`);
+            } catch (c) {
+              console.error(
+                `Failed to register JSON extension point '${a.id}' from ${o.remote}:`,
+                c
+              );
+            }
+        }
+      }
+    } catch (r) {
+      console.warn(
+        `Failed to parse JSON extension points from ${o.remote}:`,
+        r
+      );
+    }
+    if (o.init)
+      try {
+        const r = await A.loadRemoteModule(
+          o.remote,
+          "./InitPlugin"
+        );
+        if (r.default) {
+          const a = new r.default();
+          a == null || a.register();
+        }
+      } catch (r) {
+        console.warn(`Failed to load InitPlugin from ${o.remote}:`, r);
+      }
+  }
+  const e = Oe(n), t = e.experiences, s = ue(
+    {},
+    e,
+    t
+  );
+  return N.setContext({
+    extensions: s,
+    contributions: e
+  }), window.KosPlugins = window.KosPlugins || {}, window.KosPlugins.__extensions = s, s;
+}
+async function Ge(n) {
+  const { getExtensions: e } = await Ae();
+  return e(n);
+}
+const J = (n = null) => (n || window.location.search.replace("?", "")).split("&").map((e) => {
+  const [t, i] = e.split("=");
+  return [t, decodeURIComponent(i || "")];
+}).reduce((e, [t, i]) => (e[t] = i, e), {}), je = () => {
+  const n = window.location.origin, e = J();
+  return (e == null ? void 0 : e.host) || n;
+}, Je = async (n) => {
+  var z;
+  const e = je(), t = n ?? {}, {
+    pluginBaseUrl: i = e,
+    pluginApiPath: s,
+    overrides: o = {},
+    pluginContext: r
+  } = t;
+  console.log("[initialize-plugins] Config received:", {
+    propsPluginBaseUrl: n == null ? void 0 : n.pluginBaseUrl,
+    defaultHost: e,
+    resolvedPluginBaseUrl: i,
+    pluginApiPath: s
+  });
+  const a = s ? `${i}${s}` : `${i}/api/kos/ui/plugins/contexts`;
+  console.log(
+    `initialize-plugins: Using Plugin Framework. Fetching plugins from ${a}`
+  );
+  const l = await (await fetch(a)).json(), u = J(), d = u.pluginDevServers ? u.pluginDevServers.split(",").map((b) => b.trim()) : [];
+  if (d.length > 0) {
+    console.log(
+      "[initialize-plugins] Detected third-party plugin dev servers:",
+      d
+    );
+    const p = (await Promise.all(
+      d.map(async (h) => {
+        try {
+          console.log(
+            `[initialize-plugins] Fetching from dev server: ${h}`
+          );
+          const P = await fetch(
+            `${h}/api/kos/ui/plugins/contexts`
+          );
+          if (!P.ok)
+            return console.warn(
+              `[initialize-plugins] Dev server ${h} returned ${P.status}`
+            ), null;
+          const I = await P.json();
+          return { serverUrl: h, data: I };
+        } catch (P) {
+          return console.warn(
+            `[initialize-plugins] Failed to fetch from dev server ${h}:`,
+            P
+          ), null;
+        }
+      })
+    )).filter(
+      (h) => h !== null && h.data && h.data.status === 200
+    );
+    if (p.length > 0) {
+      console.log(
+        `[initialize-plugins] Merging ${p.length} dev server plugin(s)`
+      );
+      const h = {};
+      p.forEach(({ serverUrl: P, data: I }) => {
+        var $;
+        ($ = I.data) == null || $.forEach((k) => {
+          var D;
+          let S = (D = l.data) == null ? void 0 : D.find(
+            (y) => y.name === k.name
+          );
+          S || (S = { name: k.name, plugins: [] }, l.data = l.data || [], l.data.push(S)), k.plugins.forEach((y) => {
+            var x;
+            S.plugins.push(y), h[y.id] = `${P}/`, console.log(
+              `[initialize-plugins] Added dev plugin: ${(x = y.descriptor) == null ? void 0 : x.id} from ${P}`
+            );
+          });
+        });
+      }), l.overrides = {
+        ...l.overrides || {},
+        ...h
+      }, console.log(
+        "[initialize-plugins] Dev server overrides:",
+        h
+      );
+    }
+  }
+  const m = {
+    ...o,
+    ...l.overrides || {}
+  };
+  l.overrides && console.log(
+    "[initialize-plugins] Using overrides from response:",
+    l.overrides
+  ), Object.keys(m).length > 0 && console.log("[initialize-plugins] Merged overrides:", m);
+  const f = typeof (r == null ? void 0 : r.context) == "string" ? [r.context] : (r == null ? void 0 : r.context) || [], g = (z = l.data) == null ? void 0 : z.filter((b) => f.length === 0 || f.includes(b.name)).flatMap(
+    (b) => b.plugins.map((p) => ({ ...p, name: b.name })) ?? []
+  ), w = r == null ? void 0 : r.group, E = g == null ? void 0 : g.reduce((b, p) => {
+    const h = (m == null ? void 0 : m[p.id]) ?? `${i}${p.path}`;
+    if (p.descriptor) {
+      const I = (p.descriptor.extensions || []).reduce((y, x) => {
+        const F = x.groups || [];
+        return (!w || F.includes(w)) && y.push(x), y;
+      }, []), $ = p.descriptor.contributes || {};
+      let k = !1;
+      const S = Object.keys($).reduce(
+        (y, x) => {
+          if (Array.isArray($[x])) {
+            const F = ($[x] || []).filter((Y) => {
+              const Q = Y.groups || [];
+              return !w || Q.includes(w);
+            });
+            k = k || F.length > 0, y[x] = F;
+          } else
+            y[x] = $[x], k = Object.keys($[x]).length > 0;
+          return y;
+        },
+        {}
+      ), D = !!p.descriptor.init && (I.length > 0 || k);
+      b[p.id] = {
+        section: p.name,
+        basePath: `${h}remoteEntry.js`,
+        extensions: I,
+        contributes: S,
+        remote: p.descriptor.id,
+        init: D
+      };
+    } else
+      console.error(
+        `initialize-plugins: Plugin ${p.id} does not have a descriptor`
+      );
+    return b;
+  }, {});
+  window.KosPlugins = window.KosPlugins || {}, window.KosPlugins.__dynamicRemotes = E;
+  const M = Object.keys(E).reduce((b, p) => {
+    const h = E[p].remote;
+    return b[h] = E[p].basePath, b;
+  }, {});
+  return A.setRemoteDefinitions(M), M;
+};
+class Ze {
+  constructor(e) {
+    /**
+     * Reference to all plugin extensions (unfiltered)
+     */
+    v(this, "extensions");
+    /**
+     * Map of extension point to listeners
+     * Each extension point can have multiple components listening for changes
+     */
+    v(this, "listeners");
+    /**
+     * Unsubscribe function for ContributionRegistry subscription
+     * Used during cleanup to remove listener
+     */
+    v(this, "contributionUnsubscribe", null);
+    this.extensions = e, this.listeners = /* @__PURE__ */ new Map(), this.subscribeToContributionChanges();
+  }
+  /**
+   * Get extensions for an extension point (filtered by enabled state)
+   *
+   * By default, only returns enabled contributions. Use `includeDisabled: true`
+   * to get all contributions regardless of state.
+   *
+   * @param extensionPoint - Extension point identifier
+   * @param includeDisabled - If true, include disabled contributions (default: false)
+   * @returns Record of extension ID to extension object
+   *
+   * @example
+   * ```typescript
+   * // Get only enabled settings extensions
+   * const enabled = registry.getExtensions('ddk.settings.view');
+   *
+   * // Get all settings extensions (including disabled)
+   * const all = registry.getExtensions('ddk.settings.view', true);
+   * ```
+   */
+  getExtensions(e, t = !1) {
+    const i = this.extensions[e] || {};
+    return t ? i : Object.entries(i).reduce((s, [o, r]) => (N.isEnabled(o) && (s[o] = r), s), {});
+  }
+  /**
+   * Subscribe to changes for a specific extension point
+   *
+   * Registers a listener that will be called whenever contributions for
+   * the specified extension point change state (enabled/disabled) or when
+   * the best contribution for that point changes.
+   *
+   * @param extensionPoint - Extension point identifier to monitor
+   * @param listener - Callback function to handle change events
+   * @returns Unsubscribe function to stop receiving events
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = registry.subscribe('ddk.settings.view', (event) => {
+   *   if (event.changeType === 'best-changed') {
+   *     console.log('New best contribution:', event.newBest);
+   *   }
+   * });
+   *
+   * // Later...
+   * unsubscribe();
+   * ```
+   */
+  subscribe(e, t) {
+    if (typeof t != "function")
+      throw new TypeError(
+        "ReactiveExtensionRegistry.subscribe: listener must be a function"
+      );
+    return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t), () => {
+      var i, s;
+      (i = this.listeners.get(e)) == null || i.delete(t), ((s = this.listeners.get(e)) == null ? void 0 : s.size) === 0 && this.listeners.delete(e);
+    };
+  }
+  /**
+   * Internal: Subscribe to contribution state changes
+   *
+   * Sets up subscription to ContributionRegistry to receive notifications
+   * when any contribution's enabled state changes. Routes these events to
+   * extension point-specific listeners.
+   *
+   * @private
+   */
+  subscribeToContributionChanges() {
+    this.contributionUnsubscribe = N.subscribe(
+      (e) => this.handleContributionChange(e)
+    );
+  }
+  /**
+   * Internal: Handle contribution state change
+   *
+   * Called when ContributionRegistry emits a state change event.
+   * Determines if the "best" contribution has changed and emits
+   * ExtensionPointChangeEvent to all listeners for that extension point.
+   *
+   * @param event - Contribution state change event from ContributionRegistry
+   * @private
+   */
+  handleContributionChange(e) {
+    const { contributionId: t, extensionPoint: i, enabled: s } = e;
+    if (!this.listeners.has(i))
+      return;
+    this.extensions[i];
+    const o = ae(
+      this.getExtensions(i)
+    ), r = s ? "contribution-enabled" : "contribution-disabled", a = this.listeners.get(i);
+    if (a) {
+      const c = {
+        extensionPoint: i,
+        changeType: r,
+        affectedContribution: t,
+        newBest: o == null ? void 0 : o.id,
+        timestamp: e.timestamp
+      };
+      a.forEach((l) => {
+        try {
+          l(c);
+        } catch (u) {
+          console.error(
+            `ReactiveExtensionRegistry: Error in listener for '${i}':`,
+            u
+          );
+        }
+      });
+    }
+  }
+  /**
+   * Cleanup subscriptions and listeners
+   *
+   * Call this when the registry is no longer needed to prevent memory leaks.
+   * Typically called when the PluginsProvider is unmounted.
+   *
+   * @example
+   * ```typescript
+   * useEffect(() => {
+   *   const registry = new ReactiveExtensionRegistry(extensions);
+   *   // Use registry...
+   *   return () => registry.destroy();
+   * }, []);
+   * ```
+   */
+  destroy() {
+    var e;
+    (e = this.contributionUnsubscribe) == null || e.call(this), this.contributionUnsubscribe = null, this.listeners.clear();
+  }
+}
+function W(n) {
+  const e = n.match(/^(\d+)\.(\d+)\.\d+(?:-\S+)?$/);
+  if (!e)
+    throw new Error(`Invalid version format: ${n}`);
+  const [t, i, s] = e;
+  return `${i}.${s}.0`;
+}
+function Ye(n, e) {
+  var l, u;
+  e != null && e.sdkVersion && console.log("sdkVersion", e.sdkVersion), e != null && e.ddkVersion && console.log("ddkVersion", e.ddkVersion);
+  const t = W((e == null ? void 0 : e.sdkVersion) || "0.2.0"), i = W((e == null ? void 0 : e.ddkVersion) || "0.2.0");
+  console.log(`Using DDK version: ${i}`), console.log(`Using SDK version: ${t}`);
+  const s = n == null ? void 0 : n.name;
+  if (!s)
+    throw new Error(
+      "KOS Configuration should be added.  Project name not found in config"
+    );
+  const r = ((e == null ? void 0 : e.pluginPath) || "kos.ui.plugin").split(".").reduce((d, m) => (console.log(`Accessing key: ${m}`), d && d[m] ? d[m] : void 0), n), a = r == null ? void 0 : r.id;
+  if (!a)
+    throw new Error(
+      "KOS Configuration should be added.  Plugin ID not found in config"
+    );
+  const c = Object.keys(((l = r == null ? void 0 : r.contributes) == null ? void 0 : l.views) || {}).reduce(
+    (d, m) => (r.contributes.views[m].forEach((g) => {
+      d[`./${g.component}`] = g.location;
+    }), d),
+    {}
+  );
+  return Object.values(((u = r == null ? void 0 : r.contributes) == null ? void 0 : u.experiences) || {}).forEach(
+    (d) => {
+      c[`./${d.component}`] = d.location;
+    }
+  ), r != null && r.init && (c["./InitPlugin"] = "./src/app/init.ts"), {
+    name: s,
+    exposes: c,
+    library: { type: "var", name: a },
+    additionalShared: [
+      {
+        libraryName: "@kosdev-code/kos-ui-plugin",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          requiredVersion: `~${i}`
+        }
+      },
+      {
+        libraryName: "react",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !0,
+          requiredVersion: "18.2.0"
+        }
+      },
+      {
+        libraryName: "react-dom",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !0,
+          requiredVersion: "18.2.0"
+        }
+      },
+      {
+        libraryName: "@kosdev-code/kos-ui-sdk",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: `~${t}`
+        }
+      },
+      {
+        libraryName: "@kosdev-code/kos-dispense-sdk",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: `~${t}`
+        }
+      },
+      {
+        libraryName: "@kosdev-code/kos-freestyle-sdk",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: `~${t}`
+        }
+      },
+      {
+        libraryName: "@kosdev-code/kos-ddk-components",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: `~${i}`
+        }
+      },
+      {
+        libraryName: "@kosdev-code/kos-ddk-model-components",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: `~${i}`
+        }
+      },
+      {
+        libraryName: "@kosdev-code/kos-ddk-models",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: `~${i}`
+        }
+      },
+      {
+        libraryName: "@kosdev-code/kos-ddk",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: `~${i}`
+        }
+      },
+      {
+        libraryName: "@kosdev-code/kos-ddk-styles",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: `~${i}`
+        }
+      },
+      {
+        libraryName: "@emotion/styled",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "~11.11.0"
+        }
+      },
+      {
+        libraryName: "@emotion/react",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "~11.11.0"
+        }
+      },
+      {
+        libraryName: "reflect-metadata",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^0.2.2"
+        }
+      },
+      {
+        libraryName: "mobx",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^6.9.0"
+        }
+      },
+      {
+        libraryName: "loglevel",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^1.8.1"
+        }
+      },
+      {
+        libraryName: "robot3",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^0.4.0"
+        }
+      },
+      {
+        libraryName: "mobx-react-lite",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^3.4.3"
+        }
+      },
+      {
+        libraryName: "react-router-dom",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^6.11.2"
+        }
+      },
+      {
+        libraryName: "date-fns",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^2.30.0"
+        }
+      },
+      {
+        libraryName: "@use-gesture/react",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^10.3.0"
+        }
+      },
+      {
+        libraryName: "@react-spring/web",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^9.7.3"
+        }
+      },
+      {
+        libraryName: "react-simple-keyboard",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^3.6.13"
+        }
+      },
+      {
+        libraryName: "expr-eval",
+        sharedConfig: {
+          singleton: !0,
+          eager: !1,
+          strictVersion: !1,
+          requiredVersion: "^2.0.2"
+        }
+      },
+      {
+        libraryName: "zod",
+        sharedConfig: {
+          singleton: !0,
+          eager: !0,
+          strictVersion: !1,
+          requiredVersion: "^3.25.0"
+        }
+      }
+    ]
+  };
+}
+const Z = V.object({
+  id: V.string().min(1, "ID is required").describe("Unique identifier for this extension"),
+  title: V.string().min(1, "Title is required").describe("Display title shown in the interface"),
+  namespace: V.string().min(1, "Namespace is required").describe("Namespace for organizing related extensions"),
+  experienceId: V.string().min(1, "Experience ID is required").describe("Reference to the UI component experience for rendering")
+}), Ke = Z.extend({
+  rank: V.number().int().min(0).optional().describe("Optional ranking for ordering (higher = preferred)")
+});
+function Qe(n, e, t) {
+  const i = n.safeParse(e);
+  return i.success ? !0 : (i.error.errors.forEach((s) => {
+    t.addError(`${s.path.join(".")}: ${s.message}`);
+  }), !1);
+}
+function Xe(n, e, t) {
+  e && !e.includes(".") && t.addWarning(
+    `${n} '${e}' should typically include dot notation (e.g., 'category.item')`
+  );
+}
+function Le(n, e, t = 1e3) {
+  n !== void 0 && n > t && e.addWarning(
+    `Rank ${n} seems unusually high - consider using lower values for better ordering`
+  );
+}
+function et(n, e = {}) {
+  return (e.rankable ? Ke : Z).extend(n);
+}
+function tt(n, e, t = 1e3) {
+  typeof n == "object" && n !== null && "rank" in n && Le(n.rank, e, t);
+}
+class q {
+  /**
+   * Get all extension points with their plugin information
+   */
+  static getExtensionPoints(e, t = {}) {
+    const {
+      includeLegacyExtensions: i = !0,
+      includeEmptyExtensionPoints: s = !0
+    } = t, r = C().getAllExtensionPoints(), a = [];
+    return r.forEach((c) => {
+      const l = Object.values((e == null ? void 0 : e[c.id]) || {});
+      !s && l.length === 0 || a.push({
+        id: c.id,
+        displayName: c.config.displayName,
+        description: c.config.description,
+        source: "simplified",
+        metadata: c.config.metadata,
+        pluginCount: l.length,
+        plugins: l
+      });
+    }), i && e && Object.entries(e).forEach(([c, l]) => {
+      if (a.some((d) => d.id === c))
+        return;
+      const u = Object.values(l || {});
+      !s && u.length === 0 || a.push({
+        id: c,
+        source: "legacy",
+        pluginCount: u.length,
+        plugins: u
+      });
+    }), a.sort((c, l) => c.id.localeCompare(l.id));
+  }
+  /**
+   * Filter extension points based on search criteria
+   */
+  static filterExtensionPoints(e, t) {
+    if (!t.trim())
+      return e;
+    const i = t.toLowerCase();
+    return e.filter(
+      (s) => {
+        var o, r, a, c, l, u;
+        return s.id.toLowerCase().includes(i) || ((o = s.displayName) == null ? void 0 : o.toLowerCase().includes(i)) || ((r = s.description) == null ? void 0 : r.toLowerCase().includes(i)) || ((c = (a = s.metadata) == null ? void 0 : a.category) == null ? void 0 : c.toLowerCase().includes(i)) || ((u = (l = s.metadata) == null ? void 0 : l.tags) == null ? void 0 : u.some((d) => d.toLowerCase().includes(i)));
+      }
+    );
+  }
+  /**
+   * Calculate health statistics for the plugin system
+   */
+  static calculateHealthStats(e) {
+    const t = e.length, i = e.filter(
+      (c) => c.pluginCount > 0
+    ).length, s = e.reduce(
+      (c, l) => c + l.pluginCount,
+      0
+    ), o = e.filter(
+      (c) => c.source === "simplified"
+    ).length, r = e.filter(
+      (c) => c.source === "legacy"
+    ).length, a = e.filter(
+      (c) => {
+        var l;
+        return (l = c.metadata) == null ? void 0 : l.deprecated;
+      }
+    ).length;
+    return {
+      totalExtensionPoints: t,
+      extensionPointsWithPlugins: i,
+      totalPlugins: s,
+      simplifiedExtensionPoints: o,
+      legacyExtensionPoints: r,
+      deprecatedExtensionPoints: a
+    };
+  }
+  /**
+   * Analyze a specific plugin for health and capabilities
+   */
+  static analyzePlugin(e) {
+    const t = !!e.component, i = typeof e.rank == "number", s = e.rank || 0, o = [];
+    if (t ? o.push("UI Component") : o.push("Background Service"), i && o.push(`Rank: ${s}`), e.namespace) {
+      const a = e.namespace;
+      a.includes("kos") || a.includes("ddk") ? o.push("First-party") : o.push("Third-party");
+    }
+    e.modalMode && o.push(`Modal: ${e.modalMode}`);
+    let r = "healthy";
+    return e.remote || (r = "warning"), {
+      hasComponent: t,
+      hasRank: i,
+      healthStatus: r,
+      capabilities: o
+    };
+  }
+  /**
+   * Get extension point by ID with detailed information
+   */
+  static getExtensionPointById(e, t) {
+    return e.find((i) => i.id === t);
+  }
+  /**
+   * Validate if an extension point ID follows conventions
+   */
+  static validateExtensionPointId(e) {
+    const t = [], i = [];
+    e.includes(".") || (t.push(
+      "Extension point ID should contain at least one dot (namespace.feature)"
+    ), i.push('Use format like "ddk.myFeature" or "app.myFeature"'));
+    const s = e.split(".");
+    s.length < 2 && t.push(
+      "Extension point ID should have at least 2 parts (namespace.feature)"
+    );
+    const o = s[0];
+    return o && !["ddk", "cui", "app"].includes(o) && !o.endsWith("app") && i.push(
+      "Consider using standard namespaces: ddk, cui, or [appname]app"
+    ), s.some((a) => /[A-Z]/.test(a)) && (t.push("Extension point ID parts should be lowercase"), i.push(
+      'Use kebab-case or dot notation: "my.feature" not "my.myFeature"'
+    )), {
+      isValid: t.length === 0,
+      issues: t,
+      suggestions: i
+    };
+  }
+  /**
+   * Validate a plugin descriptor structure and content
+   */
+  static validatePluginDescriptor(e) {
+    const t = [], i = [], s = [], o = [];
+    if (e.id ? e.id.match(/^[a-z0-9-]+$/) || o.push(
+      "Plugin ID convention: use lowercase letters, numbers, and hyphens (e.g., 'my-awesome-plugin')"
+    ) : (s.push("id"), t.push("Plugin descriptor must have an 'id' field")), !e.contributes)
+      i.push(
+        "Plugin has no contributions - it won't extend any functionality"
+      ), o.push("Add a 'contributes' section with plugin contributions");
+    else {
+      const r = Object.keys(e.contributes);
+      r.length === 0 && i.push("Plugin contributes section is empty"), r.forEach((a) => {
+        const c = e.contributes[a];
+        if (!Array.isArray(c)) {
+          t.push(`Contribution '${a}' must be an array`);
+          return;
+        }
+        c.forEach((l, u) => {
+          l.id || t.push(
+            `Contribution ${a}[${u}] missing required 'id' field`
+          ), a === "experiences" && l.component && !l.location && (t.push(
+            `Experience '${l.id}' has component but no location`
+          ), o.push(
+            "Add 'location' field pointing to the component file"
+          )), ["cui", "utilities", "settings", "setup"].includes(a) && (l.title || i.push(
+            `${a} contribution '${l.id}' missing 'title' field`
+          ), l.namespace || i.push(
+            `${a} contribution '${l.id}' missing 'namespace' field`
+          ), l.experienceId || t.push(
+            `${a} contribution '${l.id}' missing required 'experienceId' field`
+          ));
+        });
+      });
+    }
+    return e.init !== void 0 && typeof e.init != "boolean" && t.push("'init' field must be a boolean value"), {
+      isValid: t.length === 0 && s.length === 0,
+      errors: t,
+      warnings: i,
+      missingRequired: s,
+      suggestions: o
+    };
+  }
+  /**
+   * Check compatibility between plugin contributions and available extension points
+   */
+  static checkPluginCompatibility(e, t) {
+    const i = [], s = [], o = [], r = [];
+    if (!e.contributes)
+      return {
+        isCompatible: !0,
+        issues: ["Plugin has no contributions to check"],
+        missingExtensionPoints: [],
+        incompatibleTypes: [],
+        suggestions: []
+      };
+    const a = C(), c = new Set(
+      t.map((l) => l.id)
+    );
+    return Object.entries(e.contributes).forEach(
+      ([l, u]) => {
+        this.getExpectedExtensionPoints(l).forEach((g) => {
+          c.has(g) || (s.push(g), i.push(
+            `Extension point '${g}' not available for '${l}' contributions`
+          ), r.push(
+            `Ensure the extension point '${g}' is registered`
+          ));
+        });
+        const f = a.getAllExtensionPoints().find(
+          (g) => g.config.contributionKey === l
+        );
+        f && u.length > 0 && u.forEach((g, w) => {
+          f.config.isRankable && typeof g.rank != "number" && (i.push(
+            `${l}[${w}]: Extension point '${f.id}' expects 'rank' property`
+          ), r.push(
+            "Add 'rank' property with numeric value for ordering"
+          )), f.config.hasView && !g.experienceId && (i.push(
+            `${l}[${w}]: Extension point '${f.id}' expects 'experienceId' for view-based contributions`
+          ), r.push(
+            "Add 'experienceId' property linking to an experience definition"
+          ));
+        });
+      }
+    ), {
+      isCompatible: i.length === 0,
+      issues: i,
+      missingExtensionPoints: s,
+      incompatibleTypes: o,
+      suggestions: r
+    };
+  }
+  /**
+   * Map contribution keys to their expected extension point IDs
+   */
+  static getExpectedExtensionPoints(e) {
+    return {
+      cui: ["ddk.cui", "ddk.cui.view", "ddk.cui.settings.config"],
+      utilities: ["ddk.utility", "ddk.utility.view", "ddk.utilities"],
+      setup: ["ddk.setup", "ddk.setup.view"],
+      settings: ["ddk.settings", "ddk.settings.view"],
+      troubleActions: ["ddk.troubleAction", "ddk.troubleAction.view"],
+      navViews: ["ddk.nav", "ddk.nav.view"],
+      controlPour: ["ddk.controlPour", "ddk.controlPour.view"],
+      experiences: [],
+      // Experiences don't directly map to extension points
+      views: []
+      // Views are mapped by their extension point ID keys
+    }[e] || [];
+  }
+  /**
+   * Get comprehensive plugin analysis including validation and compatibility
+   */
+  static analyzePluginDescriptor(e, t) {
+    const i = this.validatePluginDescriptor(e), s = this.checkPluginCompatibility(
+      e,
+      t
+    ), o = [];
+    return i.warnings.length > 0 && o.push(
+      "Address validation warnings to improve plugin quality"
+    ), s.isCompatible || o.push(
+      "Resolve compatibility issues before deploying plugin"
+    ), e.contributes && Object.keys(e.contributes).length === 1 && o.push(
+      "Consider adding more contribution types to increase plugin value"
+    ), {
+      validation: i,
+      compatibility: s,
+      recommendations: o
+    };
+  }
+}
+class nt {
+  /**
+   * Generate complete documentation for all extension points
+   */
+  static generateFullDocumentation(e, t = {}) {
+    const {
+      includeUsageExamples: i = !0,
+      includeTypeDefinitions: s = !0,
+      includeLegacyExtensions: o = !0,
+      includePluginHealth: r = !0
+    } = t, a = q.getExtensionPoints(
+      e,
+      {
+        includeLegacyExtensions: o,
+        includeEmptyExtensionPoints: !0
+      }
+    ), c = q.calculateHealthStats(a);
+    let l = this.generateHeader(c);
+    return l += this.generateTableOfContents(a), l += this.generateOverviewSection(a, c), a.forEach((u) => {
+      l += this.generateExtensionPointSection(u, {
+        includeUsageExamples: i,
+        includePluginHealth: r
+      });
+    }), s && (l += this.generateTypeDefinitionsSection(a)), l += this.generateContributionGuide(), l += this.generateTroubleshootingSection(), {
+      content: l,
+      metadata: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        totalExtensionPoints: c.totalExtensionPoints,
+        totalPlugins: c.totalPlugins,
+        simplifiedExtensionPoints: c.simplifiedExtensionPoints,
+        legacyExtensionPoints: c.legacyExtensionPoints
+      }
+    };
+  }
+  /**
+   * Generate documentation header with metadata
+   */
+  static generateHeader(e) {
+    return `# KOS Plugin Extension Points Reference
+
+**Generated**: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+
+## System Overview
+
+- **Total Extension Points**: ${e.totalExtensionPoints}
+- **Extension Points with Plugins**: ${e.extensionPointsWithPlugins}
+- **Total Active Plugins**: ${e.totalPlugins}
+- **Simplified Extension Points**: ${e.simplifiedExtensionPoints}
+- **Legacy Extension Points**: ${e.legacyExtensionPoints}
+
+---
+
+`;
+  }
+  /**
+   * Generate table of contents
+   */
+  static generateTableOfContents(e) {
+    let t = `## Table of Contents
+
+`;
+    return t += `- [Overview](#overview)
+`, t += `- [Extension Points](#extension-points)
+`, e.forEach((i) => {
+      const s = i.id.toLowerCase().replace(/\./g, "");
+      t += `  - [${i.id}](#${s}) (${i.pluginCount} plugins)
+`;
+    }), t += `- [Type Definitions](#type-definitions)
+`, t += `- [Contribution Guide](#contribution-guide)
+`, t += `- [Troubleshooting](#troubleshooting)
+
+`, t;
+  }
+  /**
+   * Generate overview section with health statistics
+   */
+  static generateOverviewSection(e, t) {
+    let i = `## Overview
+
+`;
+    return i += "This document provides a comprehensive reference for all available extension points in the KOS plugin system. ", i += `Extension points allow plugins to contribute functionality to the application.
+
+`, i += `### Extension Point Types
+
+`, i += "- ** Simplified Extension Points**: Use the new simplified API from `defineExtensionPoint`\n", i += `- ** Legacy Extension Points**: Use the traditional reducer-based system
+
+`, t.deprecatedExtensionPoints > 0 && (i += `### ⚠️ Deprecated Extension Points
+
+`, i += `${t.deprecatedExtensionPoints} extension points are marked as deprecated. `, i += `Consider migrating to newer alternatives.
+
+`), i + `---
+
+`;
+  }
+  /**
+   * Generate documentation section for a single extension point
+   */
+  static generateExtensionPointSection(e, t) {
+    var r;
+    const { includeUsageExamples: i = !0, includePluginHealth: s = !0 } = t;
+    let o = `## ${e.id}
+
+`;
+    if (e.displayName && (o += `**Display Name**: ${e.displayName}
+
+`), e.description && (o += `**Description**: ${e.description}
+
+`), o += `**Source**: ${e.source}
+`, o += `**Active Plugins**: ${e.pluginCount}
+
+`, e.metadata) {
+      o += `### Metadata
+
+`;
+      const a = e.metadata;
+      a.category && (o += `- **Category**: ${a.category}
+`), a.owner && (o += `- **Owner**: ${a.owner}
+`), a.since && (o += `- **Since**: ${a.since}
+`), (r = a.tags) != null && r.length && (o += `- **Tags**: ${a.tags.join(", ")}
+`), a.deprecated && (o += `- **⚠️ Status**: Deprecated
+`), o += `
+`;
+    }
+    return i && (o += this.generateUsageExamples(e)), e.plugins.length > 0 ? o += this.generatePluginList(
+      e.plugins,
+      s
+    ) : o += `### Plugins
+
+No plugins currently registered for this extension point.
+
+`, o += this.generateSchemaFieldsSection(e), o += this.generateContributionStructure(e), o + `---
+
+`;
+  }
+  /**
+   * Generate usage examples for an extension point
+   */
+  static generateUsageExamples(e) {
+    let t = `### Usage Examples
+
+`;
+    return e.source === "simplified" && (t += `#### Using Simplified API
+
+`, t += "```typescript\n", t += `// Import the extension point
+`, t += `import { ${this.getExtensionPointImportName(
+      e.id
+    )} } from './extension-points';
+
+`, t += `// Use extension component hook
+`, t += `import { useExtensionComponent } from '@kosdev-code/kos-ui-plugin';
+
+`, t += `const Component = useExtensionComponent(${this.getExtensionPointImportName(
+      e.id
+    )});
+
+`, t += `if (Component) {
+`, t += `  return (
+`, t += `    <Component 
+`, t += `      customProp="value"
+`, t += `      onComplete={handleComplete}
+`, t += `    />
+`, t += `  );
+`, t += `}
+
+`, t += `// Or use with dynamic component
+`, t += `const [Component] = useDynamicComponent({
+`, t += `  extension: ${this.getExtensionPointImportName(
+      e.id
+    )}.id
+`, t += `});
+`, t += "```\n\n", t += `#### Using Typed Hooks
+
+`, t += "```typescript\n", t += `// Get all extensions with type safety
+`, t += `const extensions = useExtensions(${this.getExtensionPointImportName(
+      e.id
+    )});
+
+`, t += `// Get best extension
+`, t += `const bestExtension = useBest(${this.getExtensionPointImportName(
+      e.id
+    )});
+
+`, t += `// Check availability
+`, t += `const hasExtensions = useHasExtensions(${this.getExtensionPointImportName(
+      e.id
+    )});
+`, t += "```\n\n"), t += `#### Using DynamicComponent
+
+`, t += "```typescript\n", t += `import { DynamicComponent } from '@kosdev-code/kos-ui-plugin';
+`, t += `import { ${this.getExtensionPointImportName(
+      e.id
+    )} } from './extension-points';
+
+`, t += `<DynamicComponent
+`, t += `  extension={${this.getExtensionPointImportName(
+      e.id
+    )}.id}
+`, t += `  props={{ customData: "value" }}
+`, t += `  fallback={<div>Loading...</div>}
+`, t += `/>
+`, t += "```\n\n", t += `#### Using Context
+
+`, t += "```typescript\n", t += `import { useKosPluginsContext } from '@kosdev-code/kos-ui-plugin';
+`, t += `import { ${this.getExtensionPointImportName(
+      e.id
+    )} } from './extension-points';
+
+`, t += `const { getExtensions } = useKosPluginsContext();
+`, t += `const extensions = getExtensions(${this.getExtensionPointImportName(
+      e.id
+    )}.id);
+`, t += "```\n\n", t;
+  }
+  /**
+   * Generate plugin list with health information
+   */
+  static generatePluginList(e, t) {
+    let i = `### Active Plugins
+
+`;
+    return e.forEach((s) => {
+      if (i += `#### ${s.id}
+
+`, s.remote && (i += `- **Remote**: ${s.remote}
+`), s.sectionId && (i += `- **Section**: ${s.sectionId}
+`), s.rank !== void 0 && (i += `- **Rank**: ${s.rank}
+`), t) {
+        const o = q.analyzePlugin(s);
+        i += `- **Health**: ${this.getHealthEmoji(o.healthStatus)} ${o.healthStatus}
+`, o.capabilities.length > 0 && (i += `- **Capabilities**: ${o.capabilities.join(", ")}
+`);
+      }
+      i += `
+`;
+    }), i;
+  }
+  /**
+   * Generate schema fields documentation
+   */
+  static generateSchemaFieldsSection(e) {
+    if (e.source !== "simplified")
+      return "";
+    const i = C().getExtensionPoint(e.id);
+    if (!(i != null && i.getSchemaFieldInfo))
+      return "";
+    const s = i.getSchemaFieldInfo();
+    if (s.length === 0)
+      return "";
+    let o = `### Schema Fields
+
+`;
+    return o += `The following fields are defined in the schema for this extension point:
+
+`, o += `| Field | Type | Required | Description |
+`, o += `|-------|------|----------|-------------|
+`, s.forEach((r) => {
+      const a = r.name, c = r.type || "unknown", l = r.required ? "✅" : "⭕", u = r.description || "-";
+      o += `| \`${a}\` | ${c} | ${l} | ${u} |
+`;
+    }), o += `
+`, o;
+  }
+  /**
+   * Generate contribution structure documentation
+   */
+  static generateContributionStructure(e) {
+    let t = `### Contribution Structure
+
+`;
+    t += `To contribute to this extension point, add the following to your plugin descriptor:
+
+`, t += "```json\n", t += `{
+`, t += `  "id": "your-plugin-id",
+`, t += `  "contributes": {
+`;
+    const i = this.inferContributionKey(e);
+    t += `    "${i}": [
+`, t += `      {
+`;
+    const s = this.getSchemaFieldsForContribution(e);
+    if (s.length > 0) {
+      const r = [];
+      s.forEach((a) => {
+        let c;
+        a.name === "id" ? c = '"your-contribution-id"' : a.name === "title" ? c = '"Your Contribution Title"' : a.name === "namespace" ? c = '"your-namespace"' : a.name === "experienceId" ? c = '"your-experience-id"' : a.name === "dashboardKey" ? c = '"your-dashboard-key"' : a.name === "rank" ? c = "10" : a.type === "string" ? c = `"your-${a.name}"` : a.type === "number" ? c = "0" : a.type === "boolean" ? c = "false" : c = `"your-${a.name}"`, (a.required || ["experienceId", "rank", "dashboardKey"].includes(a.name)) && r.push(`        "${a.name}": ${c}`);
+      }), t += r.join(`,
+`);
+    } else {
+      t += `        "id": "your-contribution-id",
+`, t += `        "title": "Your Contribution Title",
+`, t += '        "namespace": "your-namespace"', this.isViewBasedExtensionPoint(e) && (t += `,
+        "experienceId": "your-experience-id"`), this.isRankableExtensionPoint(e) && (t += `,
+        "rank": 10`);
+      const r = this.getSpecificFields(e);
+      r.length > 0 && (t += `,
+        ${r.join(`,
+        `)}`);
+    }
+    return t += `
+      }
+`, t += "    ]", (s.some((r) => r.name === "experienceId") || this.isViewBasedExtensionPoint(e)) && (t += `,
+    "experiences": {
+`, t += `      "your-experience-id": {
+`, t += `        "id": "your-experience-id",
+`, t += `        "component": "YourComponent",
+`, t += `        "location": "./src/components/YourComponent.tsx"
+`, t += `      }
+`, t += "    }"), t += `
+  }
+`, t += `}
+`, t += "```\n\n", t;
+  }
+  /**
+   * Generate TypeScript definitions section
+   */
+  static generateTypeDefinitionsSection(e) {
+    let t = `## Type Definitions
+
+`;
+    return t += `### Extension Point Types
+
+`, t += "```typescript\n", e.forEach((i) => {
+      i.source === "simplified" && (t += `// ${i.id}
+`, t += `interface ${this.getExtensionPointTypeName(i.id)} {
+`, t += `  id: "${i.id}";
+`, t += `  displayName?: "${i.displayName || ""}";
+`, t += `  description?: "${i.description || ""}";
+`, t += `}
+
+`);
+    }), t += "```\n\n", t += `### Plugin Contribution Types
+
+`, t += "```typescript\n", t += `interface BaseContribution {
+`, t += `  id: string;
+`, t += `  title: string;
+`, t += `  namespace: string;
+`, t += `}
+
+`, t += `interface ViewBasedContribution extends BaseContribution {
+`, t += `  experienceId: string;
+`, t += `}
+
+`, t += `interface RankableContribution extends BaseContribution {
+`, t += `  rank: number;
+`, t += `}
+`, t += "```\n\n", t;
+  }
+  /**
+   * Generate contribution guide
+   */
+  static generateContributionGuide() {
+    return `## Contribution Guide
+
+### Creating a Plugin
+
+1. **Create Plugin Project**
+   \`\`\`bash
+   kosui plugin-project --name my-plugin
+   \`\`\`
+
+2. **Add Components**
+   \`\`\`bash
+   kosui component --name MyComponent --pluginType utility --project my-plugin
+   \`\`\`
+
+3. **Update Plugin Descriptor**
+   Add contributions to your \`kosdev-plugin.json\` file following the structure examples above.
+
+4. **Test Integration**
+   Use the Plugin Explorer (Ctrl+Shift+P) to validate your plugin registration.
+
+### Best Practices
+
+- **Use descriptive IDs**: Plugin and contribution IDs should be clear and unique
+- **Follow naming conventions**: Use kebab-case for IDs, PascalCase for components
+- **Provide meaningful titles**: Titles are shown to users in the interface
+- **Set appropriate ranks**: Higher numbers = higher priority for rankable contributions
+- **Include proper metadata**: Namespace helps organize plugins by owner
+
+### Validation
+
+Use the Plugin Discovery Service to validate your plugin descriptor:
+
+\`\`\`typescript
+import { PluginDiscoveryService } from '@kosdev-code/kos-ui-plugin';
+
+const validation = PluginDiscoveryService.validatePluginDescriptor(yourDescriptor);
+console.log(validation.errors); // Check for errors
+console.log(validation.warnings); // Check for warnings
+\`\`\`
+
+`;
+  }
+  /**
+   * Generate troubleshooting section
+   */
+  static generateTroubleshootingSection() {
+    return `## Troubleshooting
+
+### Common Issues
+
+**Plugin not appearing in extension point**
+- Check plugin descriptor syntax
+- Verify contribution key matches extension point requirements
+- Ensure experienceId references exist in experiences section
+
+**Component fails to load**
+- Verify component path in experience location
+- Check module federation configuration
+- Use Plugin Explorer to see detailed error messages
+
+**Type errors with simplified extension points**
+- Ensure extension point is properly imported
+- Check that component props match expected interface
+- Verify extension point is registered before use
+
+### Debugging Tools
+
+**Plugin Explorer**
+- Press Ctrl+Shift+P in development mode
+- View all extension points and their plugins
+- See plugin health status and capabilities
+- Test component rendering with error boundaries
+
+**Validation Service**
+- Use \`PluginDiscoveryService.validatePluginDescriptor()\`
+- Check \`PluginDiscoveryService.checkPluginCompatibility()\`
+- Run \`PluginDiscoveryService.analyzePluginDescriptor()\` for full analysis
+
+**Browser DevTools**
+- Check \`window.KosPlugins.extensions\` for runtime state
+- Look for module federation errors in Network tab
+- Use React DevTools to inspect component loading
+
+---
+
+*Generated by KOS Plugin Documentation Generator*
+`;
+  }
+  // Helper methods
+  static getExtensionPointImportName(e) {
+    var r;
+    const i = C().getExtensionPoint(e);
+    if ((r = i == null ? void 0 : i.config.metadata) != null && r.exportName)
+      return i.config.metadata.exportName;
+    const s = e.split(".");
+    return (s.length > 1 ? s.slice(1) : s).map(
+      (a) => (
+        // Handle hyphenated parts (e.g., "pump-detail" -> "PumpDetail")
+        a.split("-").map((c) => c.charAt(0).toUpperCase() + c.slice(1)).join("")
+      )
+    ).join("") + "Extension";
+  }
+  static getExtensionPointTypeName(e) {
+    return this.getExtensionPointImportName(e) + "Type";
+  }
+  static getHealthEmoji(e) {
+    switch (e) {
+      case "healthy":
+        return "✅";
+      case "warning":
+        return "⚠️";
+      case "error":
+        return "❌";
+      default:
+        return "❓";
+    }
+  }
+  static inferContributionKey(e) {
+    if (e.source === "simplified") {
+      const r = C().getExtensionPoint(e.id);
+      if (r != null && r.config.contributionKey)
+        return r.config.contributionKey;
+    }
+    const t = e.id.split("."), i = t[t.length - 1];
+    return {
+      cui: "cui",
+      utility: "utilities",
+      utilities: "utilities",
+      setup: "setupStep",
+      settings: "settings",
+      nav: "navViews",
+      troubleAction: "troubleActions",
+      controlPour: "controlPour"
+    }[i] || i + "s";
+  }
+  static isViewBasedExtensionPoint(e) {
+    if (e.source === "simplified") {
+      const i = C().getExtensionPoint(e.id);
+      return (i == null ? void 0 : i.config.hasView) || !1;
+    }
+    return e.plugins.some(
+      (t) => t.experienceId
+    );
+  }
+  static isRankableExtensionPoint(e) {
+    if (e.source === "simplified") {
+      const i = C().getExtensionPoint(e.id);
+      return (i == null ? void 0 : i.config.isRankable) || !1;
+    }
+    return e.plugins.some(
+      (t) => typeof t.rank == "number"
+    );
+  }
+  /**
+   * Get schema fields for contribution structure generation
+   */
+  static getSchemaFieldsForContribution(e) {
+    if (e.source !== "simplified")
+      return [];
+    const i = C().getExtensionPoint(e.id);
+    return i != null && i.getSchemaFieldInfo ? i.getSchemaFieldInfo() : [];
+  }
+  static getSpecificFields(e) {
+    const t = [];
+    switch (this.inferContributionKey(e)) {
+      case "utilities":
+        t.push('"utilDescriptor": "your-util-descriptor"');
+        break;
+      case "setupStep":
+        t.push('"setupDescriptor": "your-setup-descriptor"');
+        break;
+      case "settings":
+        t.push('"settingsGroup": "your-settings-group"');
+        break;
+      case "navViews":
+        t.push('"navDescriptor": "your-nav-descriptor"');
+        break;
+      case "troubleActions":
+        t.push('"troubleType": "your-trouble-type"');
+        break;
+      case "cui":
+        t.push('"cuiDescriptor": "your-cui-descriptor"');
+        break;
+    }
+    return t;
+  }
+}
+export {
+  Z as B,
+  N as C,
+  nt as D,
+  q as P,
+  Ze as R,
+  Je as a,
+  Ae as b,
+  C as c,
+  Ge as d,
+  Oe as e,
+  he as f,
+  He as g,
+  Ye as h,
+  Be as i,
+  _e as j,
+  We as k,
+  qe as l,
+  A as m,
+  L as n,
+  me as o,
+  Ke as p,
+  Xe as q,
+  ae as r,
+  Le as s,
+  et as t,
+  tt as u,
+  Qe as v
+};
+//# sourceMappingURL=documentation-generator-Di4c9D9P.js.map