@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-3BDV7RL3.js

@@ -0,0 +1,211 @@
+import {
+  SESSION_MARKER_EVENT_TYPES,
+  isSystemInjectedMessage,
+  projectSessionMarkers
+} from "./chunk-ULMAQV3T.js";
+
+// src/types/session-timeline.ts
+function projectSessionToolMeta(events) {
+  const out = [];
+  for (const event of events) {
+    if (event.type !== "tool_call_end") continue;
+    out.push({
+      id: event.id,
+      name: event.name,
+      durationMs: event.durationMs,
+      // `outputSize` is the legacy name for the same number; prefer the modern
+      // field but fall back so old journals keep their tool card stats.
+      outputBytes: event.outputBytes ?? event.outputSize,
+      outputTokens: event.outputTokens,
+      outputLines: event.outputLines,
+      ok: event.ok,
+      agentId: event.agentId
+    });
+  }
+  return out;
+}
+function projectLastRequestTokens(events) {
+  if (!events) return void 0;
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    const event = events[i];
+    if (event?.type !== "llm_response") continue;
+    const usage = event.usage;
+    const total = usage.input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+    return total > 0 ? total : void 0;
+  }
+  return void 0;
+}
+function toolMetaIndex(meta) {
+  const index = /* @__PURE__ */ new Map();
+  if (!meta) return index;
+  for (const entry of meta) index.set(entry.id, entry);
+  return index;
+}
+function imagesOf(blocks) {
+  const images = [];
+  for (const block of blocks) {
+    if (block.type !== "image") continue;
+    images.push({
+      mediaType: block.source.media_type,
+      data: block.source.data,
+      url: block.source.url
+    });
+  }
+  return images.length > 0 ? images : void 0;
+}
+function resultText(content) {
+  return typeof content === "string" ? content : JSON.stringify(content);
+}
+function projectSessionTimeline(input) {
+  const {
+    messages,
+    events,
+    thinkingPlacement = "inline",
+    textBlocks = "split",
+    textSeparator = "",
+    hideSystemInjections = true
+  } = input;
+  const markers = input.markers ?? (events ? projectSessionMarkers(events, input.markerSources ?? SESSION_MARKER_EVENT_TYPES) : []);
+  const meta = toolMetaIndex(input.toolMeta ?? (events ? projectSessionToolMeta(events) : void 0));
+  const backbone = [];
+  const toolEntries = /* @__PURE__ */ new Map();
+  let thinkingIndex = 0;
+  let lastTs = "";
+  const pushText = (role, raw, ts, final) => {
+    const text = raw.trim();
+    if (!text) return;
+    if (hideSystemInjections && isSystemInjectedMessage(text)) return;
+    if (role === "assistant") backbone.push({ kind: "assistant", ts, text, final });
+    else if (role === "system") backbone.push({ kind: "system", ts, text });
+    else backbone.push({ kind: "user", ts, text });
+  };
+  const pushThinking = (text, ts) => {
+    if (!text.trim()) return;
+    thinkingIndex += 1;
+    backbone.push({ kind: "thinking", ts, text, index: thinkingIndex });
+  };
+  for (const message of messages) {
+    const ts = message.ts ?? lastTs;
+    if (message.ts) lastTs = message.ts;
+    if (typeof message.content === "string") {
+      pushText(message.role, message.content, ts, true);
+      continue;
+    }
+    const blocks = message.content;
+    if (thinkingPlacement === "inline") {
+      for (const block of blocks) {
+        if (block.type === "thinking") pushThinking(block.thinking, ts);
+      }
+    }
+    const images = message.role === "user" ? imagesOf(blocks) : void 0;
+    const final = !blocks.some((block) => block.type === "tool_use");
+    const textParts = [];
+    const flushText = () => {
+      if (textBlocks === "join") return;
+      const text = textParts.join(textSeparator).trim();
+      if (text) pushText(message.role, text, ts, final);
+      textParts.length = 0;
+    };
+    if (textBlocks === "join") {
+      const joined = blocks.filter((block) => block.type === "text").map((block) => block.text).join(textSeparator).trim();
+      if (joined) pushText(message.role, joined, ts, final);
+    }
+    for (const block of blocks) {
+      if (block.type === "text") {
+        textParts.push(block.text);
+        continue;
+      }
+      if (block.type === "tool_use") {
+        flushText();
+        const known2 = meta.get(block.id);
+        const entry = {
+          kind: "tool",
+          ts,
+          toolUseId: block.id,
+          name: block.name,
+          input: block.input,
+          // Left undefined until a tool_result arrives: an unfinished call is
+          // not a failed one.
+          ok: known2?.ok,
+          durationMs: known2?.durationMs,
+          outputBytes: known2?.outputBytes,
+          outputTokens: known2?.outputTokens,
+          outputLines: known2?.outputLines,
+          agentId: known2?.agentId
+        };
+        backbone.push(entry);
+        toolEntries.set(block.id, entry);
+        continue;
+      }
+      if (block.type !== "tool_result") continue;
+      flushText();
+      const existing = toolEntries.get(block.tool_use_id);
+      if (existing) {
+        existing.output = resultText(block.content);
+        existing.ok = !block.is_error;
+        toolEntries.delete(block.tool_use_id);
+        continue;
+      }
+      const known = meta.get(block.tool_use_id);
+      backbone.push({
+        kind: "tool",
+        ts,
+        toolUseId: block.tool_use_id,
+        name: block.name ?? known?.name ?? block.tool_use_id,
+        output: resultText(block.content),
+        ok: !block.is_error,
+        durationMs: known?.durationMs,
+        outputBytes: known?.outputBytes,
+        outputTokens: known?.outputTokens,
+        outputLines: known?.outputLines,
+        agentId: known?.agentId
+      });
+    }
+    flushText();
+    if (thinkingPlacement === "merged-after") {
+      const joined = blocks.filter(
+        (block) => block.type === "thinking"
+      ).map((block) => block.thinking).join("\n\n");
+      pushThinking(joined.trim(), ts);
+    }
+    if (images) {
+      const last = backbone[backbone.length - 1];
+      if (last?.kind === "user" && last.ts === ts) last.images = images;
+      else backbone.push({ kind: "user", ts, text: "", images });
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < backbone.length && j < markers.length) {
+    const marker = markers[j];
+    if (marker.ts < backbone[i].ts) {
+      out.push(markerEntry(marker));
+      j += 1;
+    } else {
+      out.push(backbone[i]);
+      i += 1;
+    }
+  }
+  while (i < backbone.length) out.push(backbone[i++]);
+  while (j < markers.length) out.push(markerEntry(markers[j++]));
+  return out;
+}
+function markerEntry(marker) {
+  return {
+    kind: "marker",
+    ts: marker.ts,
+    source: marker.source,
+    level: marker.level,
+    text: marker.text,
+    agentId: marker.agentId,
+    detail: marker.detail
+  };
+}
+
+export {
+  projectSessionToolMeta,
+  projectLastRequestTokens,
+  projectSessionTimeline
+};
+//# sourceMappingURL=chunk-3BDV7RL3.js.map

package/dist/chunk-3ECENVHL.js

@@ -0,0 +1,325 @@
+import {
+  truncate
+} from "./chunk-B4AMLZPB.js";
+import {
+  ERROR_CODES,
+  WrongStackError
+} from "./chunk-25LSLC3G.js";
+
+// src/types/quota-regex.ts
+var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)(?:\s+(?:has|have))?(?:\s+been)?[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit|(?:usage|credit)[-_\s]*(?:quota|limit)(?![-_\w])|usage[-_\s]*(?:limit|quota)[-_\s]*(?:reached|exceeded|for)/i;
+var ROUTE_SCOPED_QUOTA_RE = /\b(?:for|on)\s+(?:(?:this|the)\s+)?(?:route|model)\b|\b(?:route|model)(?:[-_\s]+[\w.-]+)?[-_\s]*(?:quota|limit)\b|\b(?:quota|limit).{0,24}\b(?:for|on)\s+(?:(?:this|the)\s+)?(?:route|model)\b/i;
+
+// src/types/provider.ts
+var REASONING_EFFORT_LEVELS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function isReasoningEffort(value) {
+  return typeof value === "string" && REASONING_EFFORT_LEVELS.includes(value);
+}
+function effectiveInputTokens(usage) {
+  return usage.input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+}
+function freshInputTokens(usage) {
+  return Math.max(0, effectiveInputTokens(usage) - (usage.cacheRead ?? 0));
+}
+function totalUsageTokens(usage) {
+  return effectiveInputTokens(usage) + usage.output;
+}
+function promptCacheHitRatio(usage) {
+  const total = effectiveInputTokens(usage);
+  if (!Number.isFinite(total) || total <= 0) return 0;
+  const cached = Number.isFinite(usage.cacheRead) ? Math.max(0, usage.cacheRead ?? 0) : 0;
+  return Math.min(1, cached / total);
+}
+var CONTEXT_OVERFLOW_RE = /context.length|context.window|maximum context|max.*tokens?.*exceeded|(?:prompt|request|input|messages?).{0,12}too (?:large|long)|exceeds the context|\btokens\b.*exceed|too many tokens|reduce the length|resulted in \d+ tokens|context_length_exceeded/i;
+var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+function classifyProviderError(status, body, message) {
+  const type = body?.type;
+  const messageText = [message, body?.message, type].filter(Boolean).join("\n");
+  const text = [messageText, body?.raw].filter(Boolean).join("\n");
+  if (status === 0) return "network";
+  if (status === 408) return "timeout";
+  if (status === 599) return "stream_hang";
+  if (QUOTA_EXHAUSTED_RE.test(messageText)) return "quota_exhausted";
+  if (status === 402) return "quota_exhausted";
+  if (type === "rate_limit_error" || status === 429) return "rate_limit";
+  if (type === "overloaded_error" || status === 529) return "overloaded";
+  if (status >= 500) return "server";
+  if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
+    return "auth";
+  }
+  if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
+  if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
+    return "context_overflow";
+  }
+  if (status >= 400) return "invalid_request";
+  return "unknown";
+}
+var MAX_RESET_HINT_MS = 7 * 24 * 60 * 60 * 1e3;
+var RESET_HINT_LEAD_RE = /(?:try again|retry|resets?|resetting|available|returns?|back online|usable again)\s+(?:in|after)\s+/i;
+var RESET_AT_LEAD_RE = /resets?\s+(?:at|on)\s+/i;
+var DURATION_TOKEN_RE = /(\d+(?:\.\d+)?)\s*(ms|secs?|seconds?|s|mins?|minutes?|m|hrs?|hours?|h|days?|d)(?![a-z])/gi;
+var UNIT_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function unitMs(unit) {
+  const u = unit.toLowerCase();
+  if (u === "ms") return 1;
+  if (u.startsWith("s")) return UNIT_MS["s"];
+  if (u.startsWith("m")) return UNIT_MS["m"];
+  if (u.startsWith("h")) return UNIT_MS["h"];
+  return UNIT_MS["d"];
+}
+var ISO_TIMESTAMP_RE = /(\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:\s*(?:Z|[+-]\d{2}:?\d{2}|UTC|GMT))?)?)/i;
+function parseResetHintMs(message, now = Date.now()) {
+  if (!message) return void 0;
+  const lead = RESET_HINT_LEAD_RE.exec(message);
+  if (lead) {
+    const window = message.slice(lead.index + lead[0].length, lead.index + lead[0].length + 80);
+    let total = 0;
+    let matched = false;
+    DURATION_TOKEN_RE.lastIndex = 0;
+    for (let m = DURATION_TOKEN_RE.exec(window); m; m = DURATION_TOKEN_RE.exec(window)) {
+      const value = Number.parseFloat(m[1]);
+      if (Number.isFinite(value) && value > 0) {
+        total += value * unitMs(m[2]);
+        matched = true;
+      }
+    }
+    if (!matched) {
+      const bare = /^(?:an?\s+)?(second|minute|hour|day)\b/i.exec(window.trim());
+      if (bare) {
+        total = unitMs(bare[1]);
+        matched = true;
+      }
+    }
+    if (matched && total > 0) {
+      return Math.min(total, MAX_RESET_HINT_MS);
+    }
+  }
+  const atLead = RESET_AT_LEAD_RE.exec(message);
+  if (atLead) {
+    const window = message.slice(atLead.index + atLead[0].length);
+    const iso = ISO_TIMESTAMP_RE.exec(window);
+    if (iso) {
+      const normalized = iso[1].replace(/^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2})/, "$1T$2").replace(/\s*(UTC|GMT)$/i, "Z");
+      const ts = Date.parse(normalized);
+      if (Number.isFinite(ts) && ts > now) {
+        return Math.min(ts - now, MAX_RESET_HINT_MS);
+      }
+    }
+  }
+  return void 0;
+}
+function isRetryableKind(kind) {
+  return RETRYABLE_BY_KIND[kind];
+}
+var RETRYABLE_BY_KIND = {
+  rate_limit: true,
+  quota_exhausted: false,
+  overloaded: true,
+  server: true,
+  timeout: true,
+  network: true,
+  stream_hang: true,
+  auth: false,
+  context_overflow: false,
+  content_filter: false,
+  invalid_request: false,
+  unknown: false
+};
+function isFallbackWorthy(kind) {
+  return FALLBACK_WORTHY_BY_KIND[kind];
+}
+var FALLBACK_WORTHY_BY_KIND = {
+  rate_limit: true,
+  quota_exhausted: true,
+  overloaded: true,
+  server: true,
+  timeout: true,
+  network: true,
+  stream_hang: true,
+  auth: false,
+  context_overflow: false,
+  content_filter: false,
+  invalid_request: false,
+  unknown: false
+};
+var ProviderError = class extends WrongStackError {
+  status;
+  retryable;
+  providerId;
+  /** Canonical failure classification — see {@link ProviderErrorKind}. */
+  kind;
+  body;
+  /**
+   * Duck-type guard: checks whether an unknown value *looks like* a
+   * ProviderError by probing for its structural properties.  Use this
+   * anywhere the constructor identity might cross a package boundary
+   * (e.g. `@wrongstack/providers` creates the error, but the runner in
+   * `@wrongstack/core` checks it). A plain `instanceof ProviderError`
+   * can fail when npm hoists duplicate copies of `@wrongstack/core`,
+   * each with its own class identity.
+   *
+   * The check tests for the four invariant properties defined in the
+   * constructor: `name === 'ProviderError'`, `status` (number),
+   * `retryable` (boolean), and `kind` (string). This tolerates both
+   * true `ProviderError` instances and cross-boundary copies.
+   */
+  static isProviderError(err) {
+    if (!err || typeof err !== "object") return false;
+    const e = err;
+    const name = e.name;
+    if (typeof name !== "string" || !name.endsWith("Error")) return false;
+    return typeof e.status === "number" && typeof e.retryable === "boolean" && typeof e.kind === "string" && typeof e.describe === "function";
+  }
+  constructor(message, status, retryable, providerId, opts = {}) {
+    const kind = opts.kind ?? classifyProviderError(status, opts.body, message);
+    super({
+      message,
+      code: kindToCode(kind),
+      subsystem: "provider",
+      severity: status >= 500 ? "error" : "warning",
+      recoverable: retryable,
+      context: { providerId, status },
+      cause: opts.cause
+    });
+    this.name = "ProviderError";
+    this.status = status;
+    this.retryable = retryable;
+    this.providerId = providerId;
+    this.kind = kind;
+    this.body = opts.body;
+  }
+  /**
+   * Render a one-line, user-facing description. Designed for the CLI/TUI
+   * status line and the agent's retry warning. Avoids dumping raw JSON
+   * (which is what users see today when a 529 lands and the log message
+   * includes the full `{"type":"error",...}` body).
+   *
+   * Examples:
+   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+   *   "openai rate limited (429): Retry after 12s"
+   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+   *   "groq HTTP 500 (server error)"
+   */
+  describe() {
+    const kind = describeStatus(this.status, this.body?.type);
+    const head = `${this.providerId} ${kind}`;
+    const detail = this.body?.message?.trim();
+    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
+    if (detail && detail.length > 0) {
+      return `${head}: ${truncate(detail, 240)}${reqId}`;
+    }
+    return `${head}${reqId}`;
+  }
+};
+function isContextOverflowShaped(err) {
+  if (!(err instanceof ProviderError) && !ProviderError.isProviderError(err)) return false;
+  const providerErr = err;
+  if (providerErr.kind === "context_overflow" || providerErr.status === 413) return true;
+  if (providerErr.status < 400) return false;
+  const text = [
+    providerErr.message,
+    providerErr.body?.message,
+    providerErr.body?.type,
+    providerErr.body?.raw
+  ].filter(Boolean).join("\n");
+  return CONTEXT_OVERFLOW_RE.test(text);
+}
+function describeStatus(status, type) {
+  if (status === 0) return "network error";
+  if (status === 599) return `stream hang (${status})`;
+  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
+  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
+  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
+  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
+  if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "content_filter") return `content filtered (${status})`;
+  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
+  if (status === 408) return `timeout (${status})`;
+  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
+  if (type) return `${type} (${status})`;
+  return `HTTP ${status}`;
+}
+var StreamHangError = class extends ProviderError {
+  /** Name of the provider that hung, e.g. "zai", "anthropic". */
+  hungProviderId;
+  /** Model that was being called when the hang occurred. */
+  hungModel;
+  /** How long (ms) we waited for the next chunk before declaring a hang. */
+  hangTimeoutMs;
+  /** How many bytes were received before the hang. */
+  bytesReceived;
+  /** Elapsed time (ms) from the start of the stream until the hang. */
+  elapsedMs;
+  constructor(opts) {
+    super(
+      `Stream hang: ${opts.providerId}/${opts.model} \u2014 no data for ${opts.hangTimeoutMs}ms after ${opts.bytesReceived} bytes (${opts.elapsedMs}ms elapsed)`,
+      599,
+      true,
+      // always retryable
+      opts.providerId,
+      {
+        body: {
+          message: `Stream stalled after ${opts.elapsedMs}ms, ${opts.bytesReceived} bytes received`
+        },
+        cause: opts.cause
+      }
+    );
+    this.name = "StreamHangError";
+    this.hungProviderId = opts.providerId;
+    this.hungModel = opts.model;
+    this.hangTimeoutMs = opts.hangTimeoutMs;
+    this.bytesReceived = opts.bytesReceived;
+    this.elapsedMs = opts.elapsedMs;
+  }
+};
+var KIND_TO_CODE = {
+  network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  quota_exhausted: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
+  overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
+  context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
+  server: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  stream_hang: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  content_filter: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  invalid_request: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  unknown: ERROR_CODES.PROVIDER_INVALID_REQUEST
+};
+function kindToCode(kind) {
+  return KIND_TO_CODE[kind];
+}
+
+export {
+  QUOTA_EXHAUSTED_RE,
+  ROUTE_SCOPED_QUOTA_RE,
+  REASONING_EFFORT_LEVELS,
+  isReasoningEffort,
+  effectiveInputTokens,
+  freshInputTokens,
+  totalUsageTokens,
+  promptCacheHitRatio,
+  classifyProviderError,
+  MAX_RESET_HINT_MS,
+  parseResetHintMs,
+  isRetryableKind,
+  isFallbackWorthy,
+  ProviderError,
+  isContextOverflowShaped,
+  StreamHangError
+};
+//# sourceMappingURL=chunk-3ECENVHL.js.map

package/dist/chunk-3XPVB7BA.js

@@ -0,0 +1,135 @@
+// src/plugin/config.ts
+function resolvePluginConfig(input) {
+  const names = [.../* @__PURE__ */ new Set([...input.aliases ?? [], input.name])];
+  const options = { ...input.defaults ?? {} };
+  const sources = [];
+  let configured = false;
+  const merge = (value, source) => {
+    if (!isRecord(value)) return;
+    Object.assign(options, value);
+    configured = true;
+    if (!sources.includes(source)) sources.push(source);
+  };
+  const plugins = input.config?.plugins;
+  if (isRecord(plugins)) {
+    for (const name of names) merge(plugins[name], "legacy-plugin-map");
+  } else if (Array.isArray(plugins)) {
+    for (const candidate of plugins) {
+      if (!isPluginEntry(candidate) || !names.includes(candidate.name)) continue;
+      merge(candidate.options, "plugin-entry");
+    }
+  }
+  const extensions = input.config?.extensions;
+  for (const name of names) merge(extensions?.[name], "extension");
+  merge(input.explicitOptions, "explicit-options");
+  return { options, configured, sources };
+}
+function pluginEntryMatchesName(configuredName, name, aliases = []) {
+  for (const candidate of [name, ...aliases]) {
+    if (configuredName === candidate) return true;
+    if (configuredName === `@wrongstack/plugins/${candidate}`) return true;
+  }
+  return false;
+}
+function resolvePluginEnablement(input) {
+  if (input.config?.features?.plugins === false) {
+    return { enabled: false, source: "feature-flag" };
+  }
+  const names = [.../* @__PURE__ */ new Set([input.name, ...input.aliases ?? []])];
+  const matches = input.matches ?? ((configuredName) => pluginEntryMatchesName(configuredName, input.name, input.aliases ?? []));
+  const plugins = input.config?.plugins;
+  if (Array.isArray(plugins)) {
+    for (const candidate of plugins) {
+      if (typeof candidate === "string") {
+        if (matches(candidate)) return { enabled: true, source: "plugin-entry" };
+        continue;
+      }
+      if (!isPluginEntry(candidate) || !matches(candidate.name)) continue;
+      return { enabled: candidate.enabled !== false, source: "plugin-entry" };
+    }
+  }
+  for (const name of names) {
+    const enabled = input.config?.extensions?.[name]?.["enabled"];
+    if (typeof enabled === "boolean") return { enabled, source: "extension" };
+  }
+  return { enabled: input.defaultState === "active", source: "default" };
+}
+function resolvePluginManifestConfig(plugin, config, explicitOptions) {
+  return resolvePluginConfig({
+    name: plugin.name,
+    aliases: plugin.configAliases,
+    defaults: plugin.defaultConfig,
+    config,
+    explicitOptions
+  });
+}
+function diffPluginConfig(previous, next, fields) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(next)]);
+  const changes = [];
+  for (const key of keys) {
+    if (valuesEqual(previous[key], next[key])) continue;
+    const metadata = fields[key];
+    changes.push({
+      key,
+      lifecycle: metadata?.lifecycle ?? "immutable",
+      secret: metadata?.secret === true,
+      previous: metadata?.secret === true ? "[REDACTED]" : previous[key],
+      next: metadata?.secret === true ? "[REDACTED]" : next[key]
+    });
+  }
+  return changes;
+}
+function redactPluginConfig(options, fields) {
+  const redacted = { ...options };
+  for (const [key, metadata] of Object.entries(fields)) {
+    if (metadata.secret === true && key in redacted) redacted[key] = "[REDACTED]";
+  }
+  return redacted;
+}
+function validatePluginConfigMetadata(plugin) {
+  if (!plugin.configFields) return [];
+  const declared = plugin.configFields;
+  const expected = /* @__PURE__ */ new Set([
+    ...Object.keys(plugin.configSchema?.properties ?? {}),
+    ...Object.keys(plugin.defaultConfig ?? {})
+  ]);
+  const issues = [];
+  for (const key of expected) {
+    if (!declared[key]) issues.push(`missing configFields metadata for "${key}"`);
+  }
+  for (const [key, metadata] of Object.entries(declared)) {
+    if (!["hot", "restart", "immutable"].includes(metadata.lifecycle)) {
+      issues.push(`invalid lifecycle for configFields."${key}"`);
+    }
+  }
+  return issues;
+}
+function isPluginEntry(value) {
+  return isRecord(value) && typeof value["name"] === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function valuesEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => valuesEqual(value, right[index]));
+  }
+  if (isRecord(left) && isRecord(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => key in right && valuesEqual(left[key], right[key]));
+  }
+  return false;
+}
+
+export {
+  resolvePluginConfig,
+  pluginEntryMatchesName,
+  resolvePluginEnablement,
+  resolvePluginManifestConfig,
+  diffPluginConfig,
+  redactPluginConfig,
+  validatePluginConfigMetadata
+};
+//# sourceMappingURL=chunk-3XPVB7BA.js.map