@carrierllc/mcp 0.13.12 → 0.13.14

package/dist/{chunk-IQDAU7WA.js → chunk-DIHA6TVT.js}

@@ -1820,7 +1820,7 @@ function storefrontScreen(input) {
 // package.json
 var package_default = {
   name: "@carrierllc/mcp",
-  version: "0.13.12",
+  version: "0.13.14",
   description: "Carrier MCP \u2014 natural-language control of MVNO/eSIM fleets via eSIMVault OCS. Stdio mode for direct integration with Claude Desktop, Cursor, Windsurf, and MCP-compatible clients. Ships the `carrier` CLI (plugin install + white-label eSIM storefront scaffold).",
   license: "MIT",
   author: "Carrier (Lifecycle Innovations Limited)",
@@ -2705,7 +2705,7 @@ function packageTemplateModifyFromToolJson(changes, method) {
   return packageTemplateModifyParams(body, method);
 }
 
-// ../../packages/ocs-client/dist/chunk-N2EPJJVN.js
+// ../../packages/ocs-client/dist/chunk-MNVQV5ST.js
 import { z } from "zod";
 var OCS_V1_METHODS = /* @__PURE__ */ new Set([
   "getResellerInfo",
@@ -2749,6 +2749,10 @@ var OCS_V1_METHODS = /* @__PURE__ */ new Set([
   "resetSubsGzCounter",
   "sendMtSms"
 ]);
+var OCS_FORBIDDEN_METHODS = /* @__PURE__ */ new Set([
+  "createAccount",
+  "createSubscriber"
+]);
 var OcsResponseEnvelope = z.object({
   status: z.object({
     code: z.number(),
@@ -3050,7 +3054,7 @@ async function runWithBudget(method, attempt, budget = ocsBudgetFor(method)) {
   throw lastTimeout ?? new OcsTimeoutError(method, budget.attemptMs, budget.totalMs, Math.max(attempts, 1));
 }
 
-// ../../packages/ocs-client/dist/chunk-KZB25Q7W.js
+// ../../packages/ocs-client/dist/chunk-4F7VPWOS.js
 var RATE_LIMIT = 10;
 var WINDOW_MS = 1e3;
 var windows = /* @__PURE__ */ new Map();
@@ -3331,7 +3335,7 @@ var OcsApiError = class extends Error {
 var OcsUnknownMethodError = class extends Error {
   constructor(method) {
     super(
-      `[${method}] is not a known OCS v1 method. It is not in the verified set of ${OCS_V1_METHODS.size} methods (createAccount/createSubscriber do not exist on the OCS). If this is a genuinely new method, add it to OCS_V1_METHODS or construct the client without { strictMethods: true }.`
+      `[${method}] is not a known OCS v1 method. It is not in the verified set of ${OCS_V1_METHODS.size} methods (createAccount/createSubscriber do not exist on the OCS). ` + (OCS_FORBIDDEN_METHODS.has(method) ? `${method} is a proven phantom method and is always rejected regardless of client options.` : `If this is a genuinely new method, add it to OCS_V1_METHODS or construct the client without { strictMethods: true }.`)
     );
     this.method = method;
     this.name = "OcsUnknownMethodError";
@@ -3456,6 +3460,9 @@ var OcsClient = class {
   _warnedMethods = /* @__PURE__ */ new Set();
   _warnedValidation = /* @__PURE__ */ new Set();
   async call(method, params = {}, token) {
+    if (OCS_FORBIDDEN_METHODS.has(method)) {
+      throw new OcsUnknownMethodError(method);
+    }
     if (!OCS_V1_METHODS.has(method)) {
       if (this._strictMethods) throw new OcsUnknownMethodError(method);
       if (!this._warnedMethods.has(method)) {
@@ -4133,6 +4140,113 @@ function applySubscriberFilters(raw, args) {
   }
   return rewrapSubscriberList(raw, envelope, rows, filtered, matched);
 }
+var OCS_SUBSCRIBER_SEARCH_KEYS = [
+  "accountId",
+  "iccid",
+  "imsi",
+  "msisdn",
+  "activationCode",
+  "iccidPrefix",
+  "imsiPrefix",
+  "msisdnPrefix"
+];
+function hasSubscriberSearchKey(params) {
+  return OCS_SUBSCRIBER_SEARCH_KEYS.some((key) => {
+    const v = params[key];
+    return v !== void 0 && v !== null && String(v).trim() !== "";
+  });
+}
+function flattenResellerAccounts(raw) {
+  const records = [];
+  if (Array.isArray(raw)) {
+    records.push(...raw);
+  } else if (raw !== null && typeof raw === "object") {
+    const obj = raw;
+    if (Array.isArray(obj["reseller"])) {
+      for (const entry of obj["reseller"]) {
+        const accounts = entry?.["account"];
+        if (Array.isArray(accounts)) records.push(...accounts);
+      }
+    }
+    if (Array.isArray(obj["account"])) records.push(...obj["account"]);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const rec of records) {
+    if (rec === null || typeof rec !== "object") continue;
+    const r = rec;
+    const id = Number(r["id"] ?? r["accountId"]);
+    if (!Number.isFinite(id) || seen.has(id)) continue;
+    seen.add(id);
+    out.push(typeof r["name"] === "string" ? { id, name: r["name"] } : { id });
+  }
+  return out;
+}
+function pickDefaultAccount(accounts) {
+  if (accounts.length === 0) return void 0;
+  const first = [...accounts].sort((a, b) => a.id - b.id)[0];
+  return {
+    accountId: first.id,
+    ...first.name !== void 0 ? { name: first.name } : {},
+    accountCount: accounts.length
+  };
+}
+var NO_ACCOUNTS_MESSAGE = "OCS requires a subscriber search key, and no default account could be chosen because this reseller has no accounts yet. Create an account in OCS, or pass accountId / set preferred_account_id once one exists.";
+function lookupFailedMessage(detail) {
+  return `OCS requires a subscriber search key, and this organization's default account could not be looked up (${detail}). Pass accountId, or set preferred_account_id, or retry.`;
+}
+function errorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function resolveDefaultAccount(opts) {
+  const cached = await opts.cache?.get().catch(() => null);
+  if (cached && Number.isFinite(cached.accountId)) return { ok: true, ...cached };
+  let resellerId;
+  const given = Number(opts.resellerId);
+  if (opts.resellerId !== void 0 && opts.resellerId !== "" && Number.isFinite(given)) {
+    resellerId = given;
+  } else {
+    try {
+      const info = await opts.call("getResellerInfo", {});
+      const id = Number(info?.id);
+      if (Number.isFinite(id)) resellerId = id;
+    } catch {
+    }
+  }
+  let raw;
+  try {
+    raw = await opts.call("listResellerAccount", resellerId !== void 0 ? { resellerId } : {});
+  } catch (err) {
+    return { ok: false, reason: "lookup_failed", message: lookupFailedMessage(errorText(err)) };
+  }
+  const pick = pickDefaultAccount(flattenResellerAccounts(raw));
+  if (!pick) return { ok: false, reason: "no_accounts", message: NO_ACCOUNTS_MESSAGE };
+  await opts.cache?.put(pick).catch(() => void 0);
+  return { ok: true, ...pick };
+}
+function defaultAccountNote(pick) {
+  const label = pick.name ? `${pick.accountId} (${pick.name})` : String(pick.accountId);
+  return pick.accountCount > 1 ? `No account was specified, so this shows account ${label} only \u2014 the lowest of ${pick.accountCount} accounts under this reseller. Pass accountId to see another account.` : `No account was specified, so this shows account ${label}, the only account under this reseller.`;
+}
+async function scopeListSubscriberParams(opts) {
+  if (opts.managed || hasSubscriberSearchKey(opts.params)) return { ok: true, params: opts.params };
+  const preferred = Number(opts.preferredAccountId);
+  if (opts.preferredAccountId !== void 0 && opts.preferredAccountId.trim() !== "" && Number.isFinite(preferred)) {
+    return { ok: true, params: { ...opts.params, accountId: preferred } };
+  }
+  const resolved = await resolveDefaultAccount({
+    call: opts.call,
+    ...opts.resellerId !== void 0 ? { resellerId: opts.resellerId } : {},
+    ...opts.cache ? { cache: opts.cache } : {}
+  });
+  if (!resolved.ok) return resolved;
+  const { ok: _ok, ...pick } = resolved;
+  return {
+    ok: true,
+    params: { ...opts.params, accountId: pick.accountId },
+    defaultAccount: { ...pick, note: defaultAccountNote(pick) }
+  };
+}
 var descriptions = /* @__PURE__ */ new Map();
 function recordToolDescription(name, description) {
   if (description) descriptions.set(name, description);
@@ -4683,6 +4797,482 @@ function collapseGyStays(events) {
 function gyCountryHistoryFromResponse(response) {
   return collapseGyStays(extractGyEvents(response));
 }
+var NETWORK_DEFAULT_MODES = ["cheapest_available", "all", "custom"];
+var SYSTEM_NETWORK_DEFAULT = "cheapest_available";
+var isoOf = (r) => String(r.operator?.countryIso2 ?? "").trim().toUpperCase();
+var networkIdOf = (r) => {
+  const n = r.operator?.networkId ?? r.networkid;
+  return typeof n === "number" && Number.isFinite(n) ? n : void 0;
+};
+function normaliseCountries(countries) {
+  const out = /* @__PURE__ */ new Set();
+  for (const c of countries) {
+    const iso = String(c ?? "").trim().toUpperCase();
+    if (/^[A-Z]{2}$/.test(iso)) out.add(iso);
+  }
+  return [...out].sort();
+}
+function isRuleAvailable(rule, now) {
+  if (rule.active === false) return false;
+  if (rule.hidden === true) return false;
+  const t = now.getTime();
+  if (rule.startdate) {
+    const s = Date.parse(rule.startdate);
+    if (Number.isFinite(s) && s > t) return false;
+  }
+  if (rule.enddate) {
+    const e = Date.parse(rule.enddate);
+    if (Number.isFinite(e) && e <= t) return false;
+  }
+  return true;
+}
+function cheapestAvailableForCountry(rules, country, now) {
+  const iso = String(country ?? "").trim().toUpperCase();
+  if (!/^[A-Z]{2}$/.test(iso)) {
+    return {
+      country: iso,
+      networks: [],
+      candidateCount: 0,
+      warnings: [
+        { code: "NO_COUNTRY", message: `"${country}" is not an ISO-3166 alpha-2 country code.` }
+      ]
+    };
+  }
+  if (!rules || rules.length === 0) {
+    return {
+      country: iso,
+      networks: [],
+      candidateCount: 0,
+      warnings: [
+        {
+          code: "NO_TARIFF_DATA",
+          country: iso,
+          message: `No tariff data was available, so ${iso} stays open to all networks. It was not narrowed to the cheapest.`
+        }
+      ]
+    };
+  }
+  const best = /* @__PURE__ */ new Map();
+  const currencies = /* @__PURE__ */ new Set();
+  for (const r of rules) {
+    if (isoOf(r) !== iso) continue;
+    if (!isRuleAvailable(r, now)) continue;
+    const rate = r.datarate;
+    if (typeof rate !== "number" || !Number.isFinite(rate) || rate <= 0) continue;
+    const id = networkIdOf(r);
+    if (id === void 0) continue;
+    const currency = String(
+      r.currency?.currencycode ?? (r.currencyid !== void 0 ? `id:${r.currencyid}` : "?")
+    );
+    currencies.add(currency);
+    const cur = best.get(id);
+    if (!cur || rate < cur.datarate) {
+      best.set(id, {
+        networkId: id,
+        operatorName: String(r.operator?.operatorName ?? `network ${id}`),
+        datarate: rate,
+        currency
+      });
+    }
+  }
+  if (best.size === 0) {
+    return {
+      country: iso,
+      networks: [],
+      candidateCount: 0,
+      warnings: [
+        {
+          code: "NO_AVAILABLE_NETWORK",
+          country: iso,
+          message: `No network with a usable data rate was found for ${iso}, so it stays open to all networks. It was not narrowed to the cheapest.`
+        }
+      ]
+    };
+  }
+  if (currencies.size > 1) {
+    return {
+      country: iso,
+      networks: [],
+      candidateCount: best.size,
+      warnings: [
+        {
+          code: "MIXED_CURRENCY",
+          country: iso,
+          message: `Rates for ${iso} are in more than one currency (${[...currencies].sort().join(", ")}), so they cannot be compared. It stays open to all networks.`
+        }
+      ]
+    };
+  }
+  const min = Math.min(...[...best.values()].map((n) => n.datarate));
+  const networks = [...best.values()].filter((n) => n.datarate === min).sort((a, b) => a.networkId - b.networkId);
+  const warnings = [];
+  if (best.size === 1) {
+    warnings.push({
+      code: "SINGLE_NETWORK",
+      country: iso,
+      message: `Only one network is available for ${iso}, so "cheapest" and "all" are the same there.`
+    });
+  }
+  return { country: iso, networks, candidateCount: best.size, warnings };
+}
+function validateNetworkChoice(choice) {
+  if (!choice || typeof choice !== "object") return "A network choice must be an object.";
+  const c = choice;
+  if (!NETWORK_DEFAULT_MODES.includes(c.mode)) {
+    return `mode must be one of: ${NETWORK_DEFAULT_MODES.join(", ")}.`;
+  }
+  if (c.mode === "custom") {
+    const id = c.steeringListId;
+    if (typeof id !== "number" || !Number.isInteger(id) || id <= 0) {
+      return "mode custom needs steeringListId, a positive integer from list_steering_lists.";
+    }
+  }
+  return null;
+}
+function pickChoice(input) {
+  const layers = [
+    ["sim_override", input.simOverride],
+    ["package_override", input.packageOverride],
+    ["org_default", input.orgDefault]
+  ];
+  const skipped = [];
+  for (const [source, choice] of layers) {
+    if (choice === null || choice === void 0) continue;
+    const problem = validateNetworkChoice(choice);
+    if (problem) {
+      skipped.push({
+        code: "INVALID_CHOICE",
+        message: `The ${source.replace("_", " ")} is invalid and was ignored: ${problem}`
+      });
+      continue;
+    }
+    return { choice, source, skipped };
+  }
+  return { choice: { mode: SYSTEM_NETWORK_DEFAULT }, source: "system_default", skipped };
+}
+function resolveNetworkPlan(input) {
+  const { choice, source, skipped } = pickChoice(input);
+  const countries = normaliseCountries(input.countries);
+  const warnings = [...skipped];
+  if (choice.mode === "custom") {
+    return {
+      source,
+      mode: "custom",
+      outcome: "use_list",
+      steeringListId: choice.steeringListId,
+      // validated by pickChoice
+      networks: [],
+      perCountry: [],
+      fellBackToAll: false,
+      warnings,
+      priceBasis: null
+    };
+  }
+  if (choice.mode === "all") {
+    return {
+      source,
+      mode: "all",
+      outcome: "allow_all",
+      networks: [],
+      perCountry: [],
+      fellBackToAll: false,
+      warnings,
+      priceBasis: null
+    };
+  }
+  if (countries.length === 0) {
+    warnings.push({
+      code: "NO_COUNTRY",
+      message: "No valid country was given, so nothing could be narrowed. The SIM stays open to all networks."
+    });
+    return {
+      source,
+      mode: "cheapest_available",
+      outcome: "allow_all",
+      networks: [],
+      perCountry: [],
+      fellBackToAll: true,
+      warnings,
+      priceBasis: null
+    };
+  }
+  const perCountry = countries.map((c) => cheapestAvailableForCountry(input.tariffRules, c, input.now));
+  for (const pc of perCountry) warnings.push(...pc.warnings);
+  const byId = /* @__PURE__ */ new Map();
+  for (const pc of perCountry) for (const n of pc.networks) byId.set(n.networkId, n);
+  const networks = [...byId.values()].sort((a, b) => a.networkId - b.networkId);
+  const unresolved = perCountry.some((pc) => pc.networks.length === 0);
+  if (networks.length === 0) {
+    return {
+      source,
+      mode: "cheapest_available",
+      outcome: "allow_all",
+      networks: [],
+      perCountry,
+      fellBackToAll: true,
+      warnings,
+      priceBasis: null
+    };
+  }
+  return {
+    source,
+    mode: "cheapest_available",
+    outcome: "restrict",
+    networks,
+    perCountry,
+    fellBackToAll: unresolved,
+    warnings,
+    priceBasis: "wholesale_datarate_per_mb"
+  };
+}
+function steeringListsFromRaw(raw) {
+  const arr = Array.isArray(raw) ? raw : raw && typeof raw === "object" ? raw.data ?? raw.steeringLists ?? raw.list ?? [] : [];
+  if (!Array.isArray(arr)) return [];
+  const out = [];
+  for (const item of arr) {
+    if (!item || typeof item !== "object") continue;
+    const o = item;
+    const id = Number(o.id ?? o.steeringListId ?? o.steeringlistid);
+    if (!Number.isInteger(id) || id <= 0) continue;
+    const nets = o.networks ?? o.networkList ?? o.operators ?? [];
+    const networkIds = Array.isArray(nets) ? nets.map((n) => {
+      if (typeof n === "number") return n;
+      if (n && typeof n === "object") {
+        const r = n;
+        return Number(r.networkId ?? r.networkid ?? r.id);
+      }
+      return NaN;
+    }).filter((n) => Number.isInteger(n)) : [];
+    out.push({ id, name: String(o.name ?? o.steeringListName ?? `list ${id}`), networkIds });
+  }
+  return out;
+}
+function planAssignment(plan, lists) {
+  if (plan.outcome === "allow_all") {
+    return {
+      action: "leave_open",
+      reason: plan.fellBackToAll ? "Fell back to all networks; see warnings. No steering list is set." : "The choice is all networks. No steering list is set."
+    };
+  }
+  if (plan.outcome === "use_list") {
+    const id = plan.steeringListId;
+    const known = lists.some((l) => l.id === id);
+    return known ? { action: "assign", steeringListId: id, reason: "Chosen custom list exists." } : {
+      action: "leave_open",
+      reason: `Steering list ${id} was not found in this reseller's lists, so nothing is assigned.`
+    };
+  }
+  const want = new Set(plan.networks.map((n) => n.networkId));
+  const match = lists.find(
+    (l) => l.networkIds.length === want.size && l.networkIds.every((id) => want.has(id))
+  );
+  if (match) {
+    return {
+      action: "assign",
+      steeringListId: match.id,
+      reason: `List "${match.name}" holds exactly the cheapest networks.`
+    };
+  }
+  const countries = plan.perCountry.filter((p) => p.networks.length > 0).map((p) => p.country);
+  return {
+    action: "needs_list",
+    networks: plan.networks,
+    suggestedName: `cheapest-${countries.join("-").toLowerCase()}`,
+    reason: "No existing list holds exactly these networks. Creating one has no REST method; it needs the browser agent or the OCS dashboard."
+  };
+}
+function tariffRulesFromRaw(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["rule", "listTariffRule", "rules", "data"]) {
+      const v = obj[key];
+      if (Array.isArray(v)) return v;
+      if (v && typeof v === "object") {
+        const nested = v.rule;
+        if (Array.isArray(nested)) return nested;
+      }
+    }
+  }
+  return null;
+}
+var NETWORK_DEFAULT_KEY_PREFIX = "netdefault:";
+function networkDefaultKey(partition) {
+  return `${NETWORK_DEFAULT_KEY_PREFIX}${partition}`;
+}
+function parseStoredNetworkDefault(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (validateNetworkChoice(r) !== null) return null;
+  const choice = {
+    mode: r.mode,
+    updatedAt: typeof r.updatedAt === "string" ? r.updatedAt : ""
+  };
+  if (r.mode === "custom") choice.steeringListId = r.steeringListId;
+  if (typeof r.updatedBy === "string") choice.updatedBy = r.updatedBy;
+  return choice;
+}
+var listNetworks = (ns) => ns.map((n) => `${n.operatorName} (${n.datarate} ${n.currency}/MB)`).join(", ");
+function buildNetworkPlanReport(input) {
+  const plan = resolveNetworkPlan({
+    countries: input.countries,
+    tariffRules: input.tariffError ? null : tariffRulesFromRaw(input.tariffRaw),
+    orgDefault: input.orgDefault ?? null,
+    packageOverride: input.packageOverride ?? null,
+    simOverride: input.simOverride ?? null,
+    now: input.now
+  });
+  if (input.tariffError && plan.mode === "cheapest_available") {
+    plan.warnings.push({
+      code: "FETCH_FAILED",
+      message: `The tariff could not be read (${input.tariffError}).`
+    });
+  }
+  if (input.steeringListsError) {
+    plan.warnings.push({
+      code: "FETCH_FAILED",
+      message: `The steering lists could not be read (${input.steeringListsError}).`
+    });
+  }
+  let assignment;
+  if (input.steeringListsError && (plan.outcome === "restrict" || plan.outcome === "use_list")) {
+    assignment = {
+      action: "leave_open",
+      reason: "The steering lists could not be read, so no list can be matched or checked. Nothing is assigned."
+    };
+  } else {
+    assignment = planAssignment(plan, steeringListsFromRaw(input.steeringListsRaw));
+  }
+  let summary;
+  if (plan.outcome === "restrict") {
+    summary = `Cheapest available: ${listNetworks(plan.networks)}.`;
+    if (plan.fellBackToAll) summary += " Some countries could not be narrowed and stay open to all networks.";
+  } else if (plan.outcome === "use_list") {
+    summary = `Custom steering list ${plan.steeringListId}.`;
+  } else if (plan.fellBackToAll) {
+    summary = "FELL BACK TO ALL NETWORKS: the cheapest network could not be determined. See warnings.";
+  } else {
+    summary = "All networks are allowed (chosen).";
+  }
+  return { plan, assignment, applied: false, summary };
+}
+function networkDefaultPartition(identity) {
+  if (identity.orgId) return identity.orgId;
+  return `user:${identity.sub.replace(/^clerk_/, "")}`;
+}
+var fail = (status, code, error) => ({
+  ok: false,
+  status,
+  error,
+  code
+});
+var msg = (e) => e instanceof Error ? e.message : String(e);
+function parseOptionalChoice(value, label) {
+  if (value === void 0 || value === null) return { choice: null };
+  const problem = validateNetworkChoice(value);
+  if (problem) return { error: `${label}: ${problem}` };
+  const v = value;
+  return { choice: v.mode === "custom" ? { mode: "custom", steeringListId: v.steeringListId } : { mode: v.mode } };
+}
+var NO_STORE_WARNING = {
+  code: "INVALID_CHOICE",
+  message: "This surface has no stored org default (local stdio mode), so it could not be read. Only the system default and the overrides you pass apply here."
+};
+async function getNetworkDefault(io) {
+  const pending = io.readStored();
+  const warnings = [];
+  let stored = null;
+  if (pending === void 0) {
+    warnings.push(NO_STORE_WARNING);
+  } else {
+    const raw = await Promise.resolve(pending).catch(() => null);
+    stored = parseStoredNetworkDefault(raw);
+    if (raw !== null && raw !== void 0 && stored === null) {
+      warnings.push({
+        code: "INVALID_CHOICE",
+        message: "The stored org default is unreadable and was ignored; the system default applies."
+      });
+    }
+  }
+  return {
+    ok: true,
+    data: {
+      modes: NETWORK_DEFAULT_MODES,
+      systemDefault: SYSTEM_NETWORK_DEFAULT,
+      orgDefault: stored,
+      effectiveMode: stored?.mode ?? SYSTEM_NETWORK_DEFAULT,
+      warnings,
+      appliesTo: "new_assignments_only"
+    }
+  };
+}
+async function setNetworkDefault(io, body, actor, now) {
+  const parsed = parseOptionalChoice(body, "body");
+  if ("error" in parsed) return fail(400, "VALIDATION_ERROR", parsed.error);
+  if (parsed.choice === null) return fail(400, "VALIDATION_ERROR", "body: A network choice must be an object.");
+  const choice = parsed.choice;
+  if (!io.writeStored) {
+    return fail(501, "NO_STORE", "This surface has no store for the org default. Set it through the REST API, the Console or the hosted MCP server.");
+  }
+  if (choice.mode === "custom") {
+    let listsRaw;
+    try {
+      listsRaw = await io.callOcs("listSteeringList", await io.resolveResellerId());
+    } catch (e) {
+      return fail(502, "OCS_ERROR", msg(e));
+    }
+    if (!steeringListsFromRaw(listsRaw).some((l) => l.id === choice.steeringListId)) {
+      return fail(400, "VALIDATION_ERROR", `Steering list ${choice.steeringListId} was not found. Pick one from list_steering_lists.`);
+    }
+  }
+  const record = { ...choice, updatedAt: now.toISOString(), updatedBy: actor };
+  await io.writeStored(record);
+  return { ok: true, data: { orgDefault: record, appliesTo: "new_assignments_only" } };
+}
+async function planNetworkDefault(io, req, now) {
+  if (!req || !Array.isArray(req.countries) || req.countries.length === 0) {
+    return fail(400, "VALIDATION_ERROR", "countries required: a non-empty array of ISO-3166 alpha-2 codes");
+  }
+  const sim = parseOptionalChoice(req.simOverride, "simOverride");
+  if ("error" in sim) return fail(400, "VALIDATION_ERROR", sim.error);
+  const pkg = parseOptionalChoice(req.packageOverride, "packageOverride");
+  if ("error" in pkg) return fail(400, "VALIDATION_ERROR", pkg.error);
+  let resellerId;
+  if (req.resellerId !== void 0 && req.resellerId !== null) {
+    resellerId = Number(req.resellerId);
+    if (!Number.isInteger(resellerId) || resellerId <= 0) {
+      return fail(400, "VALIDATION_ERROR", "resellerId must be a positive integer");
+    }
+  } else {
+    try {
+      resellerId = await io.resolveResellerId();
+    } catch (e) {
+      return fail(502, "OCS_ERROR", msg(e));
+    }
+  }
+  const settle = async (method) => {
+    try {
+      return { data: await io.callOcs(method, resellerId), error: null };
+    } catch (e) {
+      return { data: void 0, error: msg(e) };
+    }
+  };
+  const [tariff, lists, view] = await Promise.all([settle("getCustomerTariff"), settle("listSteeringList"), getNetworkDefault(io)]);
+  const orgDefault = view.ok && view.data.orgDefault ? view.data.orgDefault.mode === "custom" ? { mode: "custom", steeringListId: view.data.orgDefault.steeringListId } : { mode: view.data.orgDefault.mode } : null;
+  const report = buildNetworkPlanReport({
+    countries: req.countries.map((x) => String(x)),
+    tariffRaw: tariff.data,
+    tariffError: tariff.error,
+    steeringListsRaw: lists.data,
+    steeringListsError: lists.error,
+    orgDefault,
+    packageOverride: pkg.choice,
+    simOverride: sim.choice,
+    now
+  });
+  if (view.ok) report.plan.warnings.push(...view.data.warnings);
+  return { ok: true, data: report };
+}
 
 // src/lib/storefront-logo.ts
 function clampHex(hex, fallback) {
@@ -4786,6 +5376,7 @@ export {
   buildListSubscriberParams,
   extractSubscriberStatus,
   applySubscriberFilters,
+  scopeListSubscriberParams,
   recordToolDescription,
   buildRouterCatalog,
   ROUTER_RULES,
@@ -4808,6 +5399,12 @@ export {
   networkEventRows,
   summarizeNetworkEvents,
   gyCountryHistoryFromResponse,
+  NETWORK_DEFAULT_MODES,
+  networkDefaultKey,
+  networkDefaultPartition,
+  getNetworkDefault,
+  setNetworkDefault,
+  planNetworkDefault,
   generateStorefrontLogo,
   run,
   which,
@@ -4846,4 +5443,4 @@ export {
   storefrontScreen,
   CARRIER_VERSION
 };
-//# sourceMappingURL=chunk-IQDAU7WA.js.map
+//# sourceMappingURL=chunk-DIHA6TVT.js.map