@timeax/digital-service-engine 0.0.1

package/dist/core/index.cjs

@@ -0,0 +1,2933 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  collectFailedFallbacks: () => collectFailedFallbacks,
+  createBuilder: () => createBuilder,
+  createNodeIndex: () => createNodeIndex,
+  getEligibleFallbacks: () => getEligibleFallbacks,
+  normalise: () => normalise,
+  resolveServiceFallback: () => resolveServiceFallback,
+  validate: () => validate,
+  validateRateCoherenceDeep: () => validateRateCoherenceDeep
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/core/normalise.ts
+var import_lodash_es = require("lodash-es");
+function normalise(input, opts = {}) {
+  var _a, _b;
+  const defRole = (_a = opts.defaultPricingRole) != null ? _a : "base";
+  const constraints = (_b = opts.constraints) != null ? _b : ["refill", "cancel", "dripfeed"];
+  const obj = toObject(input);
+  const rawFilters = Array.isArray(obj.filters) ? obj.filters : [];
+  const rawFields = Array.isArray(obj.fields) ? obj.fields : [];
+  const includes_for_buttons = toStringArrayMap(
+    obj.includes_for_buttons
+  );
+  const excludes_for_buttons = toStringArrayMap(
+    obj.excludes_for_buttons
+  );
+  let filters = rawFilters.map((t) => coerceTag(t, constraints));
+  const fields = rawFields.map((f) => coerceField(f, defRole));
+  if (!filters.some((t) => t.id === "t:root")) {
+    filters = [{ id: "t:root", label: "Root" }, ...filters];
+  }
+  const fallbacks = coerceFallbacks(obj.fallbacks);
+  const out = {
+    filters,
+    fields,
+    order_for_tags: obj.order_for_tags,
+    ...isNonEmpty(includes_for_buttons) && { includes_for_buttons },
+    ...isNonEmpty(excludes_for_buttons) && { excludes_for_buttons },
+    ...fallbacks && (isNonEmpty(fallbacks.nodes) || isNonEmpty(fallbacks.global)) && {
+      fallbacks
+    },
+    schema_version: typeof obj.schema_version === "string" ? obj.schema_version : "1.0"
+  };
+  propagateConstraints(out, constraints);
+  return out;
+}
+function propagateConstraints(props, flagKeys) {
+  const tags = Array.isArray(props.filters) ? props.filters : [];
+  if (!tags.length) return;
+  const byId = new Map(tags.map((t) => [t.id, t]));
+  const children = /* @__PURE__ */ new Map();
+  for (const t of tags) {
+    const pid = t.bind_id;
+    if (!pid || !byId.has(pid)) continue;
+    if (!children.has(pid)) children.set(pid, []);
+    children.get(pid).push(t);
+  }
+  const roots = tags.filter((t) => !t.bind_id || !byId.has(t.bind_id));
+  const starts = roots.length ? roots : tags;
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (tag, inherited) => {
+    var _a, _b;
+    if (visited.has(tag.id)) return;
+    visited.add(tag.id);
+    const local = (0, import_lodash_es.cloneDeep)((_a = tag.constraints) != null ? _a : {});
+    if (tag.constraints_overrides) {
+      for (const [k, over] of Object.entries(tag.constraints_overrides)) {
+        if (over) local[k] = over.from;
+      }
+    }
+    const next = {};
+    const origin = {};
+    const overrides = {};
+    for (const k of flagKeys) {
+      const inh = inherited[k];
+      const prev = local[k];
+      if (inh) {
+        if (prev === void 0 || prev === inh.val) {
+          next[k] = inh.val;
+          origin[k] = inh.origin;
+        } else {
+          next[k] = inh.val;
+          origin[k] = inh.origin;
+          overrides[k] = {
+            from: prev,
+            to: inh.val,
+            origin: inh.origin
+          };
+        }
+      } else if (prev !== void 0) {
+        next[k] = prev;
+        origin[k] = tag.id;
+      }
+    }
+    tag.constraints = Object.keys(next).length ? next : void 0;
+    tag.constraints_origin = Object.keys(origin).length ? origin : void 0;
+    tag.constraints_overrides = Object.keys(overrides).length ? overrides : void 0;
+    const passDown = { ...inherited };
+    for (const k of flagKeys) {
+      if (next[k] !== void 0 && origin[k] !== void 0) {
+        passDown[k] = { val: next[k], origin: origin[k] };
+      }
+    }
+    for (const c of (_b = children.get(tag.id)) != null ? _b : []) visit(c, passDown);
+  };
+  for (const r of starts) visit(r, {});
+}
+function coerceTag(src, flagKeys) {
+  if (!src || typeof src !== "object") src = {};
+  const id = str(src.id);
+  const label = str(src.label);
+  const bind_id = str(src.bind_id) || (id == "t:root" ? void 0 : "t:root");
+  const service_id = toNumberOrUndefined(src.service_id);
+  const includes = toStringArray(src.includes);
+  const excludes = toStringArray(src.excludes);
+  let constraints = void 0;
+  if (src.constraints && typeof src.constraints === "object") {
+    constraints = {};
+    for (const k of flagKeys) {
+      const v = src.constraints[k];
+      if (v !== void 0) {
+        constraints[k] = bool(v);
+      }
+    }
+    if (Object.keys(constraints).length === 0) {
+      constraints = void 0;
+    }
+  }
+  const constraints_overrides = src.constraints_overrides && typeof src.constraints_overrides === "object" ? src.constraints_overrides : void 0;
+  const meta = src.meta && typeof src.meta === "object" ? src.meta : void 0;
+  const tag = {
+    id: "",
+    label: "",
+    ...id && { id },
+    ...label && { label },
+    ...bind_id && { bind_id },
+    ...service_id !== void 0 && { service_id },
+    ...constraints && { constraints },
+    ...constraints_overrides && { constraints_overrides },
+    ...includes.length && { includes: dedupe(includes) },
+    ...excludes.length && { excludes: dedupe(excludes) },
+    ...meta && { meta }
+  };
+  return tag;
+}
+function coerceField(src, defRole) {
+  if (!src || typeof src !== "object") src = {};
+  const bind_id = normaliseBindId(src.bind_id);
+  const type = str(src.type) || "text";
+  const id = str(src.id);
+  const name = typeof src.name === "string" ? src.name : void 0;
+  const label = str(src.label) || "";
+  const required = !!src.required;
+  const ui = src.ui && typeof src.ui === "object" ? src.ui : void 0;
+  const defaults = src.defaults && typeof src.defaults === "object" ? src.defaults : void 0;
+  const pricing_role = src.pricing_role === "utility" || src.pricing_role === "base" ? src.pricing_role : defRole;
+  const srcHasOptions = Array.isArray(src.options) && src.options.length > 0;
+  const options = srcHasOptions ? src.options.map((o) => coerceOption(o, pricing_role)) : void 0;
+  const component = type === "custom" ? str(src.component) || void 0 : void 0;
+  const meta = src.meta && typeof src.meta === "object" ? { ...src.meta } : void 0;
+  const button = srcHasOptions ? true : src.button === true;
+  const field_service_id_raw = toNumberOrUndefined(src.service_id);
+  const field_service_id = button && pricing_role !== "utility" && field_service_id_raw !== void 0 ? field_service_id_raw : void 0;
+  const field = {
+    id,
+    type,
+    ...bind_id !== void 0 && { bind_id },
+    ...name && { name },
+    ...options && options.length && { options },
+    ...component && { component },
+    pricing_role,
+    label,
+    required,
+    ...ui && { ui },
+    ...defaults && { defaults },
+    ...meta && { meta },
+    ...button ? { button } : {},
+    ...field_service_id !== void 0 && { service_id: field_service_id }
+  };
+  return field;
+}
+function coerceOption(src, inheritRole) {
+  if (!src || typeof src !== "object") src = {};
+  const id = str(src.id);
+  const label = str(src.label);
+  const service_id = toNumberOrUndefined(src.service_id);
+  const value = typeof src.value === "string" || typeof src.value === "number" ? src.value : void 0;
+  const pricing_role = src.pricing_role === "utility" || src.pricing_role === "base" ? src.pricing_role : inheritRole;
+  const meta = src.meta && typeof src.meta === "object" ? src.meta : void 0;
+  const option = {
+    id: "",
+    label: "",
+    ...id && { id },
+    ...label && { label },
+    ...value !== void 0 && { value },
+    ...service_id !== void 0 && { service_id },
+    pricing_role,
+    ...meta && { meta }
+  };
+  return option;
+}
+function coerceFallbacks(src) {
+  if (!src || typeof src !== "object") return void 0;
+  const out = {};
+  const g = src.global;
+  const n = src.nodes;
+  if (g && typeof g === "object") {
+    const rg = {};
+    for (const [k, v] of Object.entries(g)) {
+      const key = String(k);
+      const arr = toServiceIdArray(v);
+      const clean = dedupe(arr.filter((x) => String(x) !== key));
+      if (clean.length) rg[key] = clean;
+    }
+    if (Object.keys(rg).length) out.global = rg;
+  }
+  if (n && typeof n === "object") {
+    const rn = {};
+    for (const [nodeId, v] of Object.entries(n)) {
+      const key = String(nodeId);
+      const arr = toServiceIdArray(v);
+      const clean = dedupe(arr.filter((x) => String(x) !== key));
+      if (clean.length) rn[key] = clean;
+    }
+    if (Object.keys(rn).length) out.nodes = rn;
+  }
+  return out.nodes || out.global ? out : void 0;
+}
+function toObject(input) {
+  if (input && typeof input === "object")
+    return input;
+  throw new TypeError("normalise(): expected an object payload");
+}
+function normaliseBindId(bind) {
+  if (typeof bind === "string" && bind.trim()) return bind.trim();
+  if (Array.isArray(bind)) {
+    const arr = dedupe(bind.map((b) => String(b).trim()).filter(Boolean));
+    if (arr.length === 0) return void 0;
+    if (arr.length === 1) return arr[0];
+    return arr;
+  }
+  return void 0;
+}
+function toStringArrayMap(src) {
+  if (!src || typeof src !== "object") return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(src)) {
+    if (!k) continue;
+    const arr = toStringArray(v);
+    if (arr.length) out[k] = dedupe(arr);
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function toStringArray(v) {
+  if (!Array.isArray(v)) return [];
+  return v.map((x) => String(x)).filter((s) => !!s && s.trim().length > 0);
+}
+function toNumberOrUndefined(v) {
+  if (v === null || v === void 0) return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+function str(v) {
+  if (typeof v === "string" && v.trim().length > 0) return v.trim();
+  return void 0;
+}
+function bool(v) {
+  if (v === void 0) return void 0;
+  return !!v;
+}
+function dedupe(arr) {
+  return Array.from(new Set(arr));
+}
+function isNonEmpty(obj) {
+  return !!obj && Object.keys(obj).length > 0;
+}
+function toServiceIdArray(v) {
+  if (!Array.isArray(v)) return [];
+  return v.map(
+    (x) => typeof x === "number" || typeof x === "string" ? x : String(x)
+  ).filter(
+    (x) => x !== "" && x !== null && x !== void 0
+  );
+}
+
+// src/core/validate/shared.ts
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function hasAnyServiceOption(f) {
+  var _a;
+  return ((_a = f.options) != null ? _a : []).some((o) => isFiniteNumber(o.service_id));
+}
+function isBoundTo(f, tagId) {
+  const b = f.bind_id;
+  if (!b) return false;
+  return Array.isArray(b) ? b.includes(tagId) : b === tagId;
+}
+function getByPath(obj, path) {
+  if (!path) return void 0;
+  const parts = path.split(".");
+  let cur = obj;
+  for (const p of parts) {
+    if (cur == null) return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function jsonStable(v) {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function eqValue(a, b) {
+  if (Object.is(a, b)) return true;
+  return jsonStable(a) === jsonStable(b);
+}
+function includesValue(arr, needle) {
+  for (const v of arr) {
+    if (eqValue(v, needle)) return true;
+  }
+  return false;
+}
+function matchesWhere(svc, where) {
+  var _a;
+  if (!where || where.length === 0) return true;
+  const root = { service: svc };
+  for (const clause of where) {
+    const path = clause.path;
+    const op = (_a = clause.op) != null ? _a : "eq";
+    const value = clause.value;
+    const cur = getByPath(root, path);
+    if (op === "exists") {
+      if (cur === void 0 || cur === null) return false;
+      continue;
+    }
+    if (op === "truthy") {
+      if (!cur) return false;
+      continue;
+    }
+    if (op === "falsy") {
+      if (cur) return false;
+      continue;
+    }
+    if (op === "in" || op === "nin") {
+      const list = Array.isArray(value) ? value : [];
+      const hit = includesValue(list, cur);
+      if (op === "in" && !hit) return false;
+      if (op === "nin" && hit) return false;
+      continue;
+    }
+    if (op === "neq") {
+      if (eqValue(cur, value)) return false;
+      continue;
+    }
+    if (op === "sw") {
+      const s = String(cur != null ? cur : "");
+      const prefix = String(value != null ? value : "");
+      if (!s.startsWith(prefix)) return false;
+      continue;
+    }
+    if (!eqValue(cur, value)) return false;
+  }
+  return true;
+}
+function serviceFlagState(svc, flagId) {
+  const flags = svc.flags;
+  const entry = flags && typeof flags === "object" ? flags[flagId] : void 0;
+  const enabled = entry && typeof entry === "object" ? entry.enabled : void 0;
+  if (enabled === true) return true;
+  if (enabled === false) return false;
+  return void 0;
+}
+function isServiceFlagEnabled(svc, flagId) {
+  return serviceFlagState(svc, flagId) === true;
+}
+function withAffected(details, ids) {
+  if (!ids || ids.length <= 1) return details;
+  return { ...details != null ? details : {}, affectedIds: ids };
+}
+
+// src/core/validate/steps/visibility.ts
+function createFieldsVisibleUnder(v) {
+  return (tagId) => {
+    var _a, _b, _c, _d, _e, _f;
+    const tag = v.tagById.get(tagId);
+    const includesTag = new Set((_a = tag == null ? void 0 : tag.includes) != null ? _a : []);
+    const excludesTag = new Set((_b = tag == null ? void 0 : tag.excludes) != null ? _b : []);
+    const incForOpt = (_c = v.props.includes_for_buttons) != null ? _c : {};
+    const excForOpt = (_d = v.props.excludes_for_buttons) != null ? _d : {};
+    const includesOpt = /* @__PURE__ */ new Set();
+    const excludesOpt = /* @__PURE__ */ new Set();
+    for (const key of v.selectedKeys) {
+      for (const id of (_e = incForOpt[key]) != null ? _e : []) includesOpt.add(id);
+      for (const id of (_f = excForOpt[key]) != null ? _f : []) excludesOpt.add(id);
+    }
+    const merged = /* @__PURE__ */ new Map();
+    for (const f of v.fields) {
+      if (isBoundTo(f, tagId)) merged.set(f.id, f);
+      if (includesTag.has(f.id)) merged.set(f.id, f);
+      if (includesOpt.has(f.id)) merged.set(f.id, f);
+    }
+    for (const id of excludesTag) merged.delete(id);
+    for (const id of excludesOpt) merged.delete(id);
+    return Array.from(merged.values());
+  };
+}
+function validateVisibility(v) {
+  var _a, _b, _c, _d, _e;
+  for (const t of v.tags) {
+    const visible = v.fieldsVisibleUnder(t.id);
+    const seen = /* @__PURE__ */ new Map();
+    for (const f of visible) {
+      const label = ((_a = f.label) != null ? _a : "").trim();
+      if (!label) continue;
+      if (seen.has(label)) {
+        const otherId = seen.get(label);
+        v.errors.push({
+          code: "duplicate_visible_label",
+          severity: "error",
+          message: `Duplicate visible label "${label}" under tag "${t.id}".`,
+          nodeId: f.id,
+          details: withAffected(
+            { tagId: t.id, other: otherId, label },
+            otherId ? [t.id, f.id, otherId] : [t.id, f.id]
+          )
+        });
+      } else {
+        seen.set(label, f.id);
+      }
+    }
+  }
+  for (const t of v.tags) {
+    const visible = v.fieldsVisibleUnder(t.id);
+    const markers = [];
+    for (const f of visible) {
+      const q = (_b = f.meta) == null ? void 0 : _b.quantity;
+      if (q) markers.push(f.id);
+    }
+    if (markers.length > 1) {
+      v.errors.push({
+        code: "quantity_multiple_markers",
+        severity: "error",
+        message: `Multiple quantity markers found under tag "${t.id}". Only one is allowed per visible group.`,
+        nodeId: t.id,
+        details: withAffected({ tagId: t.id, markers }, [
+          t.id,
+          ...markers
+        ])
+      });
+    }
+  }
+  for (const t of v.tags) {
+    const visible = v.fieldsVisibleUnder(t.id);
+    let hasBase = false;
+    let hasUtility = false;
+    const utilityOptionIds = [];
+    for (const f of visible) {
+      for (const o of (_c = f.options) != null ? _c : []) {
+        if (!isFiniteNumber(o.service_id)) continue;
+        const role = (_e = (_d = o.pricing_role) != null ? _d : f.pricing_role) != null ? _e : "base";
+        if (role === "base") hasBase = true;
+        else if (role === "utility") {
+          hasUtility = true;
+          utilityOptionIds.push(o.id);
+        }
+      }
+    }
+    if (hasUtility && !hasBase) {
+      v.errors.push({
+        code: "utility_without_base",
+        severity: "error",
+        message: `Utility-priced options exist under tag "${t.id}" but no base-priced options were found in the same visible group.`,
+        nodeId: t.id,
+        details: withAffected({ tagId: t.id, utilityOptionIds }, [
+          t.id,
+          ...utilityOptionIds
+        ])
+      });
+    }
+  }
+}
+
+// src/core/validate/steps/structure.ts
+function validateStructure(v) {
+  const tags = v.tags;
+  const fields = v.fields;
+  if (!tags.some((t) => t.id === "root")) {
+    v.errors.push({
+      code: "root_missing",
+      severity: "error",
+      message: 'Missing required root tag with id "root".'
+    });
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const hasCycleFrom = (id) => {
+    var _a;
+    if (visiting.has(id)) return true;
+    if (visited.has(id)) return false;
+    visiting.add(id);
+    const parent = (_a = v.tagById.get(id)) == null ? void 0 : _a.bind_id;
+    if (parent && v.tagById.has(parent) && hasCycleFrom(parent))
+      return true;
+    visiting.delete(id);
+    visited.add(id);
+    return false;
+  };
+  for (const t of tags) {
+    if (hasCycleFrom(t.id)) {
+      v.errors.push({
+        code: "cycle_in_tags",
+        severity: "error",
+        message: `Cycle detected in tag parentage starting at tag "${t.id}".`,
+        nodeId: t.id,
+        details: { tagId: t.id }
+      });
+      break;
+    }
+  }
+  for (const t of tags) {
+    if (t.bind_id && !v.tagById.has(t.bind_id)) {
+      v.errors.push({
+        code: "bad_bind_reference",
+        severity: "error",
+        message: `Tag "${t.id}" binds to missing parent tag "${t.bind_id}".`,
+        nodeId: t.id,
+        details: withAffected({ ref: t.bind_id }, [t.id])
+      });
+    }
+  }
+  for (const f of fields) {
+    const b = f.bind_id;
+    if (Array.isArray(b)) {
+      for (const id of b) {
+        if (!v.tagById.has(id)) {
+          v.errors.push({
+            code: "bad_bind_reference",
+            severity: "error",
+            message: `Field "${f.id}" binds to missing tag "${id}".`,
+            nodeId: f.id,
+            details: withAffected({ ref: id }, [f.id])
+          });
+        }
+      }
+    } else if (typeof b === "string") {
+      if (!v.tagById.has(b)) {
+        v.errors.push({
+          code: "bad_bind_reference",
+          severity: "error",
+          message: `Field "${f.id}" binds to missing tag "${b}".`,
+          nodeId: f.id,
+          details: withAffected({ ref: b }, [f.id])
+        });
+      }
+    }
+  }
+  void isFiniteNumber;
+}
+
+// src/core/validate/steps/identity.ts
+function validateIdentity(v) {
+  var _a, _b;
+  const tags = v.tags;
+  const fields = v.fields;
+  {
+    const firstSeen = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of tags) {
+      if (seen.has(t.id)) {
+        v.errors.push({
+          code: "duplicate_id",
+          severity: "error",
+          message: `Duplicate id "${t.id}" found (tag).`,
+          nodeId: t.id
+          // we only know the id itself; no other id to point at
+        });
+      } else {
+        seen.add(t.id);
+        firstSeen.set(t.id, "tag");
+      }
+    }
+    for (const f of fields) {
+      if (seen.has(f.id)) {
+        const kind = (_a = firstSeen.get(f.id)) != null ? _a : "tag/field";
+        v.errors.push({
+          code: "duplicate_id",
+          severity: "error",
+          message: `Duplicate id "${f.id}" found (field) \u2014 already used by a ${kind}.`,
+          nodeId: f.id
+        });
+      } else {
+        seen.add(f.id);
+        firstSeen.set(f.id, "field");
+      }
+    }
+  }
+  {
+    const seen = /* @__PURE__ */ new Map();
+    for (const t of tags) {
+      if (!t.label || !t.label.trim()) {
+        v.errors.push({
+          code: "label_missing",
+          severity: "error",
+          message: `Tag "${t.id}" is missing a label.`,
+          nodeId: t.id,
+          details: { kind: "tag" }
+        });
+        continue;
+      }
+      const k = t.label;
+      if (seen.has(k)) {
+        const otherId = seen.get(k);
+        v.errors.push({
+          code: "duplicate_tag_label",
+          severity: "error",
+          message: `Duplicate tag label "${k}" found on tag "${t.id}".`,
+          nodeId: t.id,
+          details: withAffected(
+            { other: otherId, label: k },
+            otherId ? [t.id, otherId] : void 0
+          )
+        });
+      } else {
+        seen.set(k, t.id);
+      }
+    }
+  }
+  {
+    const seenNames = /* @__PURE__ */ new Map();
+    for (const f of fields) {
+      if (!f.label || !f.label.trim()) {
+        v.errors.push({
+          code: "label_missing",
+          severity: "error",
+          message: `Field "${f.id}" is missing a label.`,
+          nodeId: f.id,
+          details: { kind: "field" }
+        });
+      }
+      const isUserInput = !!f.name && !hasAnyServiceOption(f);
+      if (isUserInput && f.name) {
+        const k = f.name;
+        if (seenNames.has(k)) {
+          const otherId = seenNames.get(k);
+          v.errors.push({
+            code: "duplicate_field_name",
+            severity: "error",
+            message: `Duplicate field name "${k}" found on field "${f.id}".`,
+            nodeId: f.id,
+            details: withAffected(
+              { other: otherId, name: k },
+              otherId ? [f.id, otherId] : void 0
+            )
+          });
+        } else {
+          seenNames.set(k, f.id);
+        }
+      }
+    }
+  }
+  for (const f of fields) {
+    for (const o of (_b = f.options) != null ? _b : []) {
+      if (!o.label || !o.label.trim()) {
+        v.errors.push({
+          code: "label_missing",
+          severity: "error",
+          message: `Option "${o.id}" (field "${f.id}") is missing a label.`,
+          nodeId: o.id,
+          details: { kind: "option", fieldId: f.id }
+        });
+      }
+    }
+  }
+}
+
+// src/core/validate/steps/option-maps.ts
+function validateOptionMaps(v) {
+  var _a, _b;
+  const incMap = (_a = v.props.includes_for_buttons) != null ? _a : {};
+  const excMap = (_b = v.props.excludes_for_buttons) != null ? _b : {};
+  const parseKey = (key) => {
+    const parts = key.split("::");
+    const fid = parts[0];
+    const oid = parts[1];
+    if (!fid || !oid) return null;
+    return { fieldId: fid, optionId: oid };
+  };
+  const hasOption = (fid, oid) => {
+    var _a2;
+    const f = v.fieldById.get(fid);
+    if (!f) return false;
+    return !!((_a2 = f.options) != null ? _a2 : []).find((o) => o.id === oid);
+  };
+  const badKeyMessage = (key) => `Invalid option-map key "${key}". Expected "fieldId::optionId" pointing to an existing option.`;
+  for (const k of Object.keys(incMap)) {
+    const p = parseKey(k);
+    if (!p || !hasOption(p.fieldId, p.optionId)) {
+      v.errors.push({
+        code: "bad_option_key",
+        severity: "error",
+        message: badKeyMessage(k),
+        details: { key: k }
+      });
+    }
+  }
+  for (const k of Object.keys(excMap)) {
+    const p = parseKey(k);
+    if (!p || !hasOption(p.fieldId, p.optionId)) {
+      v.errors.push({
+        code: "bad_option_key",
+        severity: "error",
+        message: badKeyMessage(k),
+        details: { key: k }
+      });
+    }
+  }
+  for (const k of Object.keys(incMap)) {
+    if (k in excMap) {
+      const p = parseKey(k);
+      const affected = p ? [p.fieldId, p.optionId] : void 0;
+      v.errors.push({
+        code: "option_include_exclude_conflict",
+        severity: "error",
+        message: `Option-map key "${k}" appears in both includes_for_buttons and excludes_for_buttons.`,
+        nodeId: p == null ? void 0 : p.fieldId,
+        details: withAffected({ key: k }, affected)
+      });
+    }
+  }
+}
+
+// src/core/validate/steps/service-vs-input.ts
+function validateServiceVsUserInput(v) {
+  for (const f of v.fields) {
+    const anySvc = hasAnyServiceOption(f);
+    const hasName = !!(f.name && f.name.trim());
+    if (f.type === "custom" && anySvc) {
+      v.errors.push({
+        code: "user_input_field_has_service_option",
+        severity: "error",
+        message: `Custom field "${f.id}" cannot map service options.`,
+        nodeId: f.id,
+        details: { reason: "custom_cannot_map_service" }
+      });
+    }
+    if (!hasName) {
+      if (!anySvc) {
+        v.errors.push({
+          code: "service_field_missing_service_id",
+          severity: "error",
+          message: `Service-backed field "${f.id}" has no "name" and must provide at least one option with a service_id.`,
+          nodeId: f.id
+        });
+      }
+    } else {
+      if (anySvc) {
+        v.errors.push({
+          code: "user_input_field_has_service_option",
+          severity: "error",
+          message: `User-input field "${f.id}" has a name and must not include any options with service_id.`,
+          nodeId: f.id
+        });
+      }
+    }
+  }
+}
+
+// src/core/validate/steps/utility.ts
+function validateUtilityMarkers(v) {
+  var _a, _b, _c, _d;
+  const ALLOWED_UTILITY_MODES = /* @__PURE__ */ new Set([
+    "flat",
+    "per_quantity",
+    "per_value",
+    "percent"
+  ]);
+  for (const f of v.fields) {
+    const optsArr = Array.isArray(f.options) ? f.options : [];
+    for (const o of optsArr) {
+      const role = (_b = (_a = o.pricing_role) != null ? _a : f.pricing_role) != null ? _b : "base";
+      const hasService = isFiniteNumber(o.service_id);
+      const util = (_c = o.meta) == null ? void 0 : _c.utility;
+      if (role === "utility" && hasService) {
+        v.errors.push({
+          code: "utility_with_service_id",
+          severity: "error",
+          message: `Utility-priced option "${o.id}" (field "${f.id}") must not reference a service_id.`,
+          nodeId: o.id,
+          details: withAffected(
+            {
+              fieldId: f.id,
+              optionId: o.id,
+              service_id: o.service_id
+            },
+            [f.id, o.id]
+          )
+        });
+      }
+      if (util) {
+        const mode = util.mode;
+        const rate = util.rate;
+        if (!isFiniteNumber(rate)) {
+          v.errors.push({
+            code: "utility_missing_rate",
+            severity: "error",
+            message: `Utility definition for option "${o.id}" (field "${f.id}") is missing a valid rate.`,
+            nodeId: o.id,
+            details: withAffected(
+              { fieldId: f.id, optionId: o.id },
+              [f.id, o.id]
+            )
+          });
+        }
+        if (!ALLOWED_UTILITY_MODES.has(String(mode))) {
+          v.errors.push({
+            code: "utility_invalid_mode",
+            severity: "error",
+            message: `Utility definition for option "${o.id}" (field "${f.id}") has invalid mode "${String(
+              mode
+            )}".`,
+            nodeId: o.id,
+            details: withAffected(
+              { fieldId: f.id, optionId: o.id, mode },
+              [f.id, o.id]
+            )
+          });
+        }
+      }
+    }
+  }
+  for (const f of v.fields) {
+    const util = (_d = f.meta) == null ? void 0 : _d.utility;
+    if (!util) continue;
+    const mode = util.mode;
+    const rate = util.rate;
+    if (!isFiniteNumber(rate)) {
+      v.errors.push({
+        code: "utility_missing_rate",
+        severity: "error",
+        message: `Utility definition for field "${f.id}" is missing a valid rate.`,
+        nodeId: f.id,
+        details: withAffected({ fieldId: f.id }, [f.id])
+      });
+    }
+    if (!ALLOWED_UTILITY_MODES.has(String(mode))) {
+      v.errors.push({
+        code: "utility_invalid_mode",
+        severity: "error",
+        message: `Utility definition for field "${f.id}" has invalid mode "${String(
+          mode
+        )}".`,
+        nodeId: f.id,
+        details: withAffected({ fieldId: f.id, mode }, [f.id])
+      });
+    }
+  }
+}
+
+// src/utils/index.ts
+function isMultiField(f) {
+  var _a;
+  const t = (f.type || "").toLowerCase();
+  const metaMulti = !!((_a = f.meta) == null ? void 0 : _a.multi);
+  return t === "multiselect" || t === "checkbox" || metaMulti;
+}
+
+// src/core/validate/steps/rates.ts
+function validateRates(v) {
+  var _a, _b, _c, _d;
+  for (const f of v.fields) {
+    if (!isMultiField(f)) continue;
+    const baseRates = /* @__PURE__ */ new Set();
+    const contributingOptionIds = /* @__PURE__ */ new Set();
+    for (const o of (_a = f.options) != null ? _a : []) {
+      const role = (_c = (_b = o.pricing_role) != null ? _b : f.pricing_role) != null ? _c : "base";
+      if (role !== "base") continue;
+      const sid = o.service_id;
+      if (!isFiniteNumber(sid)) continue;
+      const rate = (_d = v.serviceMap[sid]) == null ? void 0 : _d.rate;
+      if (isFiniteNumber(rate)) {
+        baseRates.add(Number(rate));
+        contributingOptionIds.add(o.id);
+      }
+    }
+    if (baseRates.size > 1) {
+      const affectedIds = [
+        f.id,
+        ...Array.from(contributingOptionIds)
+      ];
+      v.errors.push({
+        code: "rate_mismatch_across_base",
+        severity: "error",
+        message: `Base options under field "${f.id}" resolve to different service rates.`,
+        nodeId: f.id,
+        details: withAffected(
+          {
+            fieldId: f.id,
+            rates: Array.from(baseRates.values()),
+            optionIds: Array.from(contributingOptionIds.values())
+          },
+          affectedIds.length > 1 ? affectedIds : void 0
+        )
+      });
+    }
+  }
+}
+
+// src/core/validate/steps/constraints.ts
+function constraintKeysInChain(v, tagId) {
+  const keys = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  let cur = tagId;
+  const seenTags = /* @__PURE__ */ new Set();
+  while (cur && !seenTags.has(cur)) {
+    seenTags.add(cur);
+    const t = v.tagById.get(cur);
+    const c = t == null ? void 0 : t.constraints;
+    if (c && typeof c === "object") {
+      for (const k of Object.keys(c)) {
+        if (!seenKeys.has(k)) {
+          seenKeys.add(k);
+          keys.push(k);
+        }
+      }
+    }
+    cur = t == null ? void 0 : t.bind_id;
+  }
+  return keys;
+}
+function effectiveConstraints(v, tagId) {
+  var _a;
+  const out = {};
+  const keys = constraintKeysInChain(v, tagId);
+  for (const key of keys) {
+    let cur = tagId;
+    const seen = /* @__PURE__ */ new Set();
+    while (cur && !seen.has(cur)) {
+      seen.add(cur);
+      const t = v.tagById.get(cur);
+      const val = (_a = t == null ? void 0 : t.constraints) == null ? void 0 : _a[key];
+      if (val === true || val === false) {
+        out[key] = val;
+        break;
+      }
+      cur = t == null ? void 0 : t.bind_id;
+    }
+  }
+  return out;
+}
+function validateConstraints(v) {
+  var _a, _b;
+  for (const t of v.tags) {
+    const eff = effectiveConstraints(v, t.id);
+    const hasAnyRequired = Object.values(eff).some(
+      (x) => x === true
+    );
+    if (!hasAnyRequired) continue;
+    const visible = v.fieldsVisibleUnder(t.id);
+    for (const f of visible) {
+      for (const o of (_a = f.options) != null ? _a : []) {
+        if (!isFiniteNumber(o.service_id)) continue;
+        const svc = v.serviceMap[o.service_id];
+        if (!svc || typeof svc !== "object") continue;
+        for (const [k, val] of Object.entries(eff)) {
+          if (val === true && !isServiceFlagEnabled(svc, k)) {
+            v.errors.push({
+              code: "unsupported_constraint",
+              severity: "error",
+              message: `Service option "${o.id}" under tag "${t.id}" does not support required constraint "${k}".`,
+              nodeId: t.id,
+              details: withAffected(
+                {
+                  flag: k,
+                  serviceId: o.service_id,
+                  fieldId: f.id,
+                  optionId: o.id
+                },
+                [t.id, f.id, o.id]
+              )
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const t of v.tags) {
+    const sid = t.service_id;
+    if (!isFiniteNumber(sid)) continue;
+    const svc = v.serviceMap[Number(sid)];
+    if (!svc || typeof svc !== "object") continue;
+    const eff = effectiveConstraints(v, t.id);
+    for (const [k, val] of Object.entries(eff)) {
+      if (val === true && !isServiceFlagEnabled(svc, k)) {
+        v.errors.push({
+          code: "unsupported_constraint",
+          severity: "error",
+          message: `Tag "${t.id}" maps to service "${String(
+            sid
+          )}" which does not support required constraint "${k}".`,
+          nodeId: t.id,
+          details: { flag: k, serviceId: sid }
+        });
+      }
+    }
+  }
+  for (const t of v.tags) {
+    const ov = t.constraints_overrides;
+    if (!ov || typeof ov !== "object") continue;
+    for (const k of Object.keys(ov)) {
+      const row = ov[k];
+      if (!row) continue;
+      const from = row.from === true;
+      const to = row.to === true;
+      const origin = String((_b = row.origin) != null ? _b : "");
+      v.errors.push({
+        code: "constraint_overridden",
+        severity: "warning",
+        message: origin ? `Constraint "${k}" on tag "${t.id}" was overridden by ancestor "${origin}" (${String(from)} \u2192 ${String(
+          to
+        )}).` : `Constraint "${k}" on tag "${t.id}" was overridden by an ancestor (${String(from)} \u2192 ${String(to)}).`,
+        nodeId: t.id,
+        details: withAffected(
+          { flag: k, from, to, origin },
+          origin ? [t.id, origin] : void 0
+        )
+      });
+    }
+  }
+}
+
+// src/core/validate/steps/custom.ts
+function validateCustomFields(v) {
+  for (const f of v.fields) {
+    if (f.type !== "custom") continue;
+    if (!f.component || !String(f.component).trim()) {
+      v.errors.push({
+        code: "custom_component_missing",
+        severity: "error",
+        message: `Custom field "${f.id}" is missing a valid component reference.`,
+        nodeId: f.id
+      });
+    }
+  }
+}
+
+// src/core/validate/steps/global-utility-guard.ts
+function validateGlobalUtilityGuard(v) {
+  var _a, _b, _c;
+  if (!v.options.globalUtilityGuard) return;
+  let hasUtility = false;
+  let hasBase = false;
+  for (const f of v.fields) {
+    for (const o of (_a = f.options) != null ? _a : []) {
+      if (!isFiniteNumber(o.service_id)) continue;
+      const role = (_c = (_b = o.pricing_role) != null ? _b : f.pricing_role) != null ? _c : "base";
+      if (role === "base") hasBase = true;
+      else if (role === "utility") hasUtility = true;
+      if (hasUtility && hasBase) break;
+    }
+    if (hasUtility && hasBase) break;
+  }
+  if (hasUtility && !hasBase) {
+    v.errors.push({
+      code: "utility_without_base",
+      severity: "warning",
+      message: "Global utility guard: utility-priced options exist but no base-priced options were found.",
+      nodeId: "global",
+      details: { scope: "global" }
+    });
+  }
+}
+
+// src/core/validate/steps/unbound.ts
+function validateUnboundFields(v) {
+  var _a, _b;
+  const boundFieldIds = /* @__PURE__ */ new Set();
+  for (const f of v.fields) {
+    if (f.bind_id) boundFieldIds.add(f.id);
+  }
+  const includedByTag = /* @__PURE__ */ new Set();
+  for (const t of v.tags) {
+    for (const id of (_a = t.includes) != null ? _a : []) includedByTag.add(id);
+  }
+  const includedByOption = /* @__PURE__ */ new Set();
+  for (const arr of Object.values((_b = v.props.includes_for_buttons) != null ? _b : {})) {
+    for (const id of arr != null ? arr : []) includedByOption.add(id);
+  }
+  for (const f of v.fields) {
+    if (!boundFieldIds.has(f.id) && !includedByTag.has(f.id) && !includedByOption.has(f.id)) {
+      v.errors.push({
+        code: "field_unbound",
+        severity: "error",
+        message: `Field "${f.id}" is unbound: it is not bound to any tag and not included by tags or option maps.`,
+        nodeId: f.id,
+        details: withAffected(
+          {
+            fieldId: f.id,
+            bound: false,
+            // exposing these helps editors explain "why"
+            includedByTag: includedByTag.has(f.id),
+            includedByOption: includedByOption.has(f.id)
+          },
+          [f.id]
+        )
+      });
+    }
+  }
+}
+
+// src/core/validate/steps/fallbacks.ts
+function codeForReason(reason) {
+  switch (reason) {
+    case "unknown_service":
+      return "fallback_unknown_service";
+    case "no_primary":
+      return "fallback_no_primary";
+    case "rate_violation":
+      return "fallback_rate_violation";
+    case "constraint_mismatch":
+      return "fallback_constraint_mismatch";
+    case "cycle":
+      return "fallback_cycle";
+    default:
+      return "fallback_bad_node";
+  }
+}
+function messageFor(code, d) {
+  const n = d.nodeId ? `node "${String(d.nodeId)}"` : "node";
+  switch (code) {
+    case "fallback_unknown_service":
+      return `Fallback candidate "${String(
+        d.candidate
+      )}" is unknown for ${n}.`;
+    case "fallback_no_primary":
+      return `Fallback rule has no primary service for ${n}.`;
+    case "fallback_rate_violation":
+      return `Fallback candidate "${String(
+        d.candidate
+      )}" violates the base-rate rules for ${n}.`;
+    case "fallback_constraint_mismatch":
+      return `Fallback candidate "${String(
+        d.candidate
+      )}" does not satisfy required constraints for ${n}.`;
+    case "fallback_cycle":
+      return `Fallback rules contain a cycle for ${n}.`;
+    default:
+      return `Fallback rule is invalid for ${n}.`;
+  }
+}
+function validateFallbacks(v) {
+  var _a, _b, _c, _d;
+  const mode = (_b = (_a = v.options.fallbackSettings) == null ? void 0 : _a.mode) != null ? _b : "strict";
+  if (!v.props.fallbacks) return;
+  const diags = collectFailedFallbacks(v.props, (_c = v.options.serviceMap) != null ? _c : {}, {
+    ...v.options.fallbackSettings,
+    mode: "dev"
+  });
+  if (mode !== "strict") return;
+  for (const d of diags) {
+    if (d.scope === "global") continue;
+    const code = codeForReason(
+      String((_d = d.reason) != null ? _d : "fallback_bad_node")
+    );
+    const nodeId = d.nodeId ? String(d.nodeId) : void 0;
+    const tagContext = d.tagContext;
+    const affectedIds = [];
+    if (nodeId) affectedIds.push(nodeId);
+    if (typeof tagContext === "string" && tagContext && tagContext !== nodeId)
+      affectedIds.push(tagContext);
+    v.errors.push({
+      code,
+      severity: "error",
+      message: messageFor(code, {
+        nodeId,
+        primary: d.primary,
+        candidate: d.candidate,
+        tagContext,
+        scope: d.scope
+      }),
+      nodeId,
+      details: withAffected(
+        {
+          primary: d.primary,
+          candidate: d.candidate,
+          tagContext,
+          scope: d.scope
+        },
+        affectedIds.length > 1 ? affectedIds : void 0
+      )
+    });
+  }
+}
+
+// src/core/validate/policies/collect-service-items.ts
+function asArray(v) {
+  if (v === void 0) return void 0;
+  return Array.isArray(v) ? v : [v];
+}
+function isServiceIdRef(v) {
+  return typeof v === "string" || typeof v === "number" && Number.isFinite(v);
+}
+function svcSnapshot(serviceMap, sid) {
+  const svc = serviceMap[sid];
+  if (!svc) return { id: sid };
+  const meta = svc.meta && typeof svc.meta === "object" ? svc.meta : {};
+  return {
+    ...svc,
+    id: sid,
+    ...meta
+  };
+}
+function pushItem(out, next) {
+  var _a;
+  const key = `${String(next.serviceId)}|${next.role}`;
+  const existing = out.get(key);
+  if (!existing) {
+    out.set(key, {
+      tagId: next.tagId,
+      fieldId: next.fieldId,
+      optionId: next.optionId,
+      nodeId: next.nodeId,
+      serviceId: next.serviceId,
+      role: next.role,
+      service: next.service,
+      affectedIds: Array.from(new Set(next.affectedIds))
+    });
+    return;
+  }
+  const mergedIds = Array.from(
+    /* @__PURE__ */ new Set([...existing.affectedIds, ...next.affectedIds])
+  );
+  out.set(key, {
+    ...existing,
+    tagId: (_a = existing.tagId) != null ? _a : next.tagId,
+    affectedIds: mergedIds
+  });
+}
+function fieldRoleOf(f, o) {
+  var _a, _b;
+  const roleRaw = (_b = (_a = o == null ? void 0 : o.pricing_role) != null ? _a : f.pricing_role) != null ? _b : "base";
+  return roleRaw === "utility" ? "utility" : "base";
+}
+function applyFilterAllowLists(tagId, fieldId, filter) {
+  const tagAllow = asArray(filter == null ? void 0 : filter.tag_id);
+  const fieldAllow = asArray(filter == null ? void 0 : filter.field_id);
+  if (tagAllow) {
+    if (!tagId) return false;
+    if (!tagAllow.includes(tagId)) return false;
+  }
+  if (fieldAllow) {
+    if (!fieldId) return false;
+    if (!fieldAllow.includes(fieldId)) return false;
+  }
+  return true;
+}
+function collectServiceItems(args) {
+  var _a, _b, _c, _d, _e;
+  const filter = args.filter;
+  const roleFilter = (_a = filter == null ? void 0 : filter.role) != null ? _a : "both";
+  const where = filter == null ? void 0 : filter.where;
+  const out = /* @__PURE__ */ new Map();
+  const addServiceRef = (ref) => {
+    if (roleFilter !== "both" && ref.role !== roleFilter) return;
+    if (!applyFilterAllowLists(ref.tagId, ref.fieldId, filter)) return;
+    const svc = args.serviceMap[ref.serviceId];
+    if (where && svc && !matchesWhere(svc, where)) return;
+    pushItem(out, {
+      ...ref,
+      service: svcSnapshot(args.serviceMap, ref.serviceId)
+    });
+  };
+  if (args.mode === "global") {
+    for (const t of (_b = args.tags) != null ? _b : []) {
+      const sid = t.service_id;
+      if (!isServiceIdRef(sid)) continue;
+      addServiceRef({
+        tagId: t.id,
+        serviceId: sid,
+        role: "base",
+        affectedIds: [`tag:${t.id}`, `service:${String(sid)}`]
+      });
+    }
+  } else if (args.mode === "visible_group") {
+    const t = args.tag;
+    const sid = t ? t.service_id : void 0;
+    if (t && isServiceIdRef(sid)) {
+      addServiceRef({
+        tagId: t.id,
+        serviceId: sid,
+        role: "base",
+        affectedIds: [`tag:${t.id}`, `service:${String(sid)}`]
+      });
+    }
+  }
+  const fields = (_c = args.fields) != null ? _c : [];
+  for (const f of fields) {
+    const fSid = f.service_id;
+    if (isServiceIdRef(fSid)) {
+      addServiceRef({
+        tagId: args.tagId,
+        fieldId: f.id,
+        serviceId: fSid,
+        role: "base",
+        affectedIds: [`field:${f.id}`, `service:${String(fSid)}`]
+      });
+    }
+    for (const o of (_d = f.options) != null ? _d : []) {
+      const oSid = o.service_id;
+      if (!isServiceIdRef(oSid)) continue;
+      const role = fieldRoleOf(f, o);
+      addServiceRef({
+        tagId: args.tagId,
+        fieldId: f.id,
+        optionId: o.id,
+        serviceId: oSid,
+        role,
+        affectedIds: [
+          `field:${f.id}`,
+          `option:${o.id}`,
+          `service:${String(oSid)}`
+        ]
+      });
+    }
+  }
+  const fb = args.props.fallbacks;
+  if (!fb) return Array.from(out.values());
+  const addFallbackNode = (nodeId, list) => {
+    const arr = Array.isArray(list) ? list : [];
+    for (const cand of arr) {
+      if (!isServiceIdRef(cand)) continue;
+      addServiceRef({
+        tagId: args.tagId,
+        nodeId,
+        serviceId: cand,
+        role: "base",
+        affectedIds: [`fallback-node:${nodeId}`, `service:${String(cand)}`]
+      });
+    }
+  };
+  const addFallbackGlobal = (primaryKey, list) => {
+    const primaryId = primaryKey;
+    addServiceRef({
+      tagId: args.tagId,
+      nodeId: primaryKey,
+      serviceId: primaryId,
+      role: "base",
+      affectedIds: [
+        `fallback-global-primary:${primaryKey}`,
+        `service:${String(primaryId)}`
+      ]
+    });
+    const arr = Array.isArray(list) ? list : [];
+    for (const cand of arr) {
+      if (!isServiceIdRef(cand)) continue;
+      addServiceRef({
+        tagId: args.tagId,
+        nodeId: primaryKey,
+        serviceId: cand,
+        role: "base",
+        affectedIds: [
+          `fallback-global:${primaryKey}`,
+          `service:${String(cand)}`
+        ]
+      });
+    }
+  };
+  const includeAllFallbacks = args.mode === "global";
+  const includeGroupFallbacks = args.mode === "visible_group";
+  const nodes = fb.nodes && typeof fb.nodes === "object" ? fb.nodes : void 0;
+  if (nodes) {
+    if (includeAllFallbacks) {
+      for (const [nodeId, list] of Object.entries(nodes)) {
+        addFallbackNode(nodeId, list);
+      }
+    } else if (includeGroupFallbacks) {
+      const allowNodes = new Set(
+        Array.isArray(args.visibleNodeIds) ? args.visibleNodeIds : []
+      );
+      for (const nodeId of allowNodes) {
+        addFallbackNode(nodeId, nodes[nodeId]);
+      }
+    }
+  }
+  const globalFb = fb.global && typeof fb.global === "object" ? fb.global : void 0;
+  if (globalFb) {
+    if (includeAllFallbacks) {
+      for (const [primaryKey, list] of Object.entries(globalFb)) {
+        addFallbackGlobal(primaryKey, list);
+      }
+    } else if (includeGroupFallbacks) {
+      const allowPrimaries = new Set(
+        ((_e = args.visiblePrimaries) != null ? _e : []).map((x) => String(x))
+      );
+      for (const primaryKey of allowPrimaries) {
+        const list = globalFb[primaryKey];
+        if (list === void 0) continue;
+        addFallbackGlobal(primaryKey, list);
+      }
+    }
+  }
+  return Array.from(out.values());
+}
+
+// src/core/validate/policies/ops.ts
+function evalPolicyOp(op, values, rule) {
+  switch (op) {
+    case "all_equal": {
+      const set = new Set(
+        values.map((v) => JSON.stringify(v))
+      );
+      return set.size <= 1;
+    }
+    case "no_mix": {
+      const set = new Set(
+        values.map((v) => JSON.stringify(v))
+      );
+      return set.size <= 1;
+    }
+    case "unique": {
+      const seen = /* @__PURE__ */ new Set();
+      for (const v of values) {
+        const k = JSON.stringify(v);
+        if (seen.has(k)) return false;
+        seen.add(k);
+      }
+      return true;
+    }
+    case "all_true": {
+      return values.every((v) => v === true);
+    }
+    case "any_true": {
+      return values.some((v) => v === true);
+    }
+    case "max_count": {
+      const limit = typeof rule.value === "number" ? rule.value : Infinity;
+      return values.length <= limit;
+    }
+    case "min_count": {
+      const min = typeof rule.value === "number" ? rule.value : 0;
+      return values.length >= min;
+    }
+    default:
+      return true;
+  }
+}
+
+// src/core/validate/policies/apply-policies.ts
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+function stableSeverity(s) {
+  if (s === "warning") return "warning";
+  if (s === "error") return "error";
+  return "error";
+}
+function defaultPolicyMessage(rule) {
+  if (typeof rule.message === "string" && rule.message.trim())
+    return rule.message;
+  if (typeof rule.label === "string" && rule.label.trim())
+    return rule.label.trim();
+  return `Policy "${rule.id}" violated`;
+}
+function affectedFromItems(items) {
+  var _a;
+  const ids = [];
+  for (const it of items) {
+    for (const x of (_a = it.affectedIds) != null ? _a : []) ids.push(x);
+    ids.push(`service:${String(it.serviceId)}`);
+  }
+  return uniq(ids);
+}
+function visibleGroupNodeIds(tag, fields) {
+  var _a;
+  const ids = [tag.id];
+  for (const f of fields) {
+    for (const o of (_a = f.options) != null ? _a : []) {
+      ids.push(o.id);
+    }
+  }
+  return uniq(ids);
+}
+function visibleGroupPrimaries(tag, fields) {
+  var _a;
+  const prim = [];
+  const tagSid = tag.service_id;
+  if (typeof tagSid === "string" || typeof tagSid === "number" && Number.isFinite(tagSid)) {
+    prim.push(tagSid);
+  }
+  for (const f of fields) {
+    const fsid = f.service_id;
+    if (typeof fsid === "string" || typeof fsid === "number" && Number.isFinite(fsid)) {
+      prim.push(fsid);
+    }
+    for (const o of (_a = f.options) != null ? _a : []) {
+      const osid = o.service_id;
+      if (typeof osid === "string" || typeof osid === "number" && Number.isFinite(osid)) {
+        prim.push(osid);
+      }
+    }
+  }
+  return uniq(prim);
+}
+function applyPolicies(errors, props, serviceMap, policies, fieldsVisibleUnder, tags) {
+  var _a, _b, _c, _d, _e;
+  if (!(policies == null ? void 0 : policies.length)) return;
+  const tagById = /* @__PURE__ */ new Map();
+  for (const t of tags) tagById.set(t.id, t);
+  for (const rule of policies) {
+    const projPath = (_a = rule.projection) != null ? _a : "service.id";
+    const severity = stableSeverity(
+      rule.severity
+    );
+    const message = defaultPolicyMessage(rule);
+    if (rule.scope === "global") {
+      const tagAllow = Array.isArray(
+        (_b = rule.filter) == null ? void 0 : _b.tag_id
+      ) ? (_c = rule.filter) == null ? void 0 : _c.tag_id : ((_d = rule.filter) == null ? void 0 : _d.tag_id) ? [rule.filter.tag_id] : void 0;
+      let items = [];
+      if (tagAllow && tagAllow.length) {
+        const merged = /* @__PURE__ */ new Map();
+        for (const id of tagAllow) {
+          const t = tagById.get(id);
+          if (!t) continue;
+          const visibleFields = fieldsVisibleUnder(t.id);
+          const nodeIds = visibleGroupNodeIds(
+            t,
+            visibleFields
+          );
+          const primaries = visibleGroupPrimaries(
+            t,
+            visibleFields
+          );
+          const sub = collectServiceItems({
+            mode: "visible_group",
+            props,
+            serviceMap,
+            tag: t,
+            tagId: t.id,
+            fields: visibleFields,
+            filter: rule.filter,
+            visibleNodeIds: nodeIds,
+            visiblePrimaries: primaries
+          });
+          for (const it of sub) {
+            const k = `${String(it.serviceId)}|${it.role}`;
+            const existing = merged.get(k);
+            if (!existing) {
+              merged.set(k, it);
+            } else {
+              merged.set(k, {
+                ...existing,
+                affectedIds: uniq([
+                  ...existing.affectedIds,
+                  ...it.affectedIds
+                ])
+              });
+            }
+          }
+        }
+        items = Array.from(merged.values());
+      } else {
+        const allFields = (_e = props.fields) != null ? _e : [];
+        items = collectServiceItems({
+          mode: "global",
+          props,
+          serviceMap,
+          tags,
+          fields: allFields,
+          filter: rule.filter
+        });
+      }
+      const values = items.map(
+        (it) => getByPath(it, projPath)
+      );
+      if (!evalPolicyOp(rule.op, values, rule)) {
+        errors.push({
+          code: "policy_violation",
+          severity,
+          message,
+          nodeId: "global",
+          details: {
+            ruleId: rule.id,
+            scope: "global",
+            op: rule.op,
+            projection: projPath,
+            count: items.length,
+            affectedIds: affectedFromItems(items)
+          }
+        });
+      }
+      continue;
+    }
+    for (const t of tags) {
+      const visibleFields = fieldsVisibleUnder(t.id);
+      const nodeIds = visibleGroupNodeIds(t, visibleFields);
+      const primaries = visibleGroupPrimaries(t, visibleFields);
+      const items = collectServiceItems({
+        mode: "visible_group",
+        props,
+        serviceMap,
+        tag: t,
+        tagId: t.id,
+        fields: visibleFields,
+        filter: rule.filter,
+        visibleNodeIds: nodeIds,
+        visiblePrimaries: primaries
+      });
+      if (!items.length) continue;
+      const values = items.map(
+        (it) => getByPath(it, projPath)
+      );
+      if (!evalPolicyOp(rule.op, values, rule)) {
+        errors.push({
+          code: "policy_violation",
+          severity,
+          message,
+          nodeId: t.id,
+          details: {
+            ruleId: rule.id,
+            scope: "visible_group",
+            op: rule.op,
+            projection: projPath,
+            count: items.length,
+            affectedIds: affectedFromItems(items)
+          }
+        });
+      }
+    }
+  }
+}
+
+// src/core/validate/index.ts
+function validate(props, ctx = {}) {
+  var _a, _b;
+  const errors = [];
+  const serviceMap = (_a = ctx.serviceMap) != null ? _a : {};
+  const selectedKeys = new Set(
+    (_b = ctx.selectedOptionKeys) != null ? _b : []
+  );
+  const tags = Array.isArray(props.filters) ? props.filters : [];
+  const fields = Array.isArray(props.fields) ? props.fields : [];
+  const tagById = /* @__PURE__ */ new Map();
+  const fieldById = /* @__PURE__ */ new Map();
+  for (const t of tags) tagById.set(t.id, t);
+  for (const f of fields) fieldById.set(f.id, f);
+  const v = {
+    props,
+    options: ctx,
+    errors,
+    serviceMap,
+    selectedKeys,
+    tags,
+    fields,
+    tagById,
+    fieldById,
+    fieldsVisibleUnder: (_tagId) => []
+  };
+  validateStructure(v);
+  validateIdentity(v);
+  validateOptionMaps(v);
+  v.fieldsVisibleUnder = createFieldsVisibleUnder(v);
+  validateVisibility(v);
+  applyPolicies(
+    v.errors,
+    v.props,
+    v.serviceMap,
+    v.options.policies,
+    v.fieldsVisibleUnder,
+    v.tags
+  );
+  validateServiceVsUserInput(v);
+  validateUtilityMarkers(v);
+  validateRates(v);
+  validateConstraints(v);
+  validateCustomFields(v);
+  validateGlobalUtilityGuard(v);
+  validateUnboundFields(v);
+  validateFallbacks(v);
+  return v.errors;
+}
+
+// src/core/builder.ts
+function createBuilder(opts = {}) {
+  return new BuilderImpl(opts);
+}
+var BuilderImpl = class {
+  constructor(opts = {}) {
+    this.props = {
+      filters: [],
+      fields: [],
+      schema_version: "1.0"
+    };
+    this.tagById = /* @__PURE__ */ new Map();
+    this.fieldById = /* @__PURE__ */ new Map();
+    this.optionOwnerById = /* @__PURE__ */ new Map();
+    this.history = [];
+    this.future = [];
+    var _a;
+    this.options = { ...opts };
+    this.historyLimit = (_a = opts.historyLimit) != null ? _a : 50;
+  }
+  /* ───── lifecycle ─────────────────────────────────────────────────────── */
+  load(raw) {
+    const next = normalise(raw, {
+      defaultPricingRole: "base",
+      constraints: this.getConstraints().map((item) => item.label)
+    });
+    this.pushHistory(this.props);
+    this.future.length = 0;
+    this.props = next;
+    this.rebuildIndexes();
+  }
+  getProps() {
+    return this.props;
+  }
+  setOptions(patch) {
+    this.options = { ...this.options, ...patch };
+  }
+  getServiceMap() {
+    var _a;
+    return (_a = this.options.serviceMap) != null ? _a : {};
+  }
+  getConstraints() {
+    var _a;
+    const serviceMap = this.getServiceMap();
+    const out = /* @__PURE__ */ new Set();
+    const guard = /* @__PURE__ */ new Set();
+    for (const svc of Object.values(serviceMap)) {
+      const flags = (_a = svc.flags) != null ? _a : {};
+      for (const flagId of Object.keys(flags)) {
+        if (guard.has(flagId)) continue;
+        guard.add(flagId);
+        out.add({
+          id: flagId,
+          value: flagId,
+          label: flagId,
+          description: flags[flagId].description
+        });
+      }
+    }
+    return Array.from(out);
+  }
+  /* ───── querying ─────────────────────────────────────────────────────── */
+  tree() {
+    var _a, _b, _c, _d;
+    const nodes = [];
+    const edges = [];
+    const showSet = toStringSet(this.options.showOptionNodes);
+    for (const t of this.props.filters) {
+      nodes.push({ id: t.id, kind: "tag", label: t.label });
+    }
+    for (const t of this.props.filters) {
+      if (t.bind_id) {
+        edges.push({
+          from: t.bind_id,
+          to: t.id,
+          kind: "child"
+        });
+      }
+    }
+    for (const f of this.props.fields) {
+      nodes.push({
+        id: f.id,
+        kind: "field",
+        label: f.label,
+        bind_type: f.pricing_role === "utility" ? "utility" : f.bind_id ? "bound" : null
+      });
+    }
+    for (const f of this.props.fields) {
+      const b = f.bind_id;
+      if (Array.isArray(b)) {
+        for (const tagId of b)
+          edges.push({
+            from: tagId,
+            to: f.id,
+            kind: "bind"
+          });
+      } else if (typeof b === "string") {
+        edges.push({ from: b, to: f.id, kind: "bind" });
+      }
+    }
+    for (const f of this.props.fields) {
+      const showOptions = showSet.has(f.id);
+      if (!showOptions) continue;
+      if (!Array.isArray(f.options)) continue;
+      for (const o of f.options) {
+        nodes.push({
+          id: o.id,
+          kind: "option",
+          label: o.label
+        });
+        const e = {
+          from: f.id,
+          to: o.id,
+          kind: "option",
+          meta: { ownerField: f.id }
+        };
+        edges.push(e);
+      }
+    }
+    for (const t of this.props.filters) {
+      for (const id of (_a = t.includes) != null ? _a : []) {
+        edges.push({ from: t.id, to: id, kind: "include" });
+      }
+      for (const id of (_b = t.excludes) != null ? _b : []) {
+        edges.push({ from: t.id, to: id, kind: "exclude" });
+      }
+    }
+    const incMap = (_c = this.props.includes_for_buttons) != null ? _c : {};
+    const excMap = (_d = this.props.excludes_for_buttons) != null ? _d : {};
+    const pushButtonEdge = (keyId, targetFieldId, kind) => {
+      var _a2;
+      const owner = this.optionOwnerById.get(keyId);
+      const ownerFieldId = (_a2 = owner == null ? void 0 : owner.fieldId) != null ? _a2 : this.fieldById.has(keyId) ? keyId : void 0;
+      if (!ownerFieldId) return;
+      const fromNode = owner && showSet.has(owner.fieldId) ? keyId : ownerFieldId;
+      const meta = owner ? showSet.has(owner.fieldId) ? {
+        via: "option-visible",
+        ownerField: owner.fieldId,
+        sourceOption: keyId
+      } : {
+        via: "option-hidden",
+        ownerField: owner.fieldId,
+        sourceOption: keyId
+      } : { via: "field-button" };
+      const e = { from: fromNode, to: targetFieldId, kind, meta };
+      edges.push(e);
+    };
+    for (const [keyId, arr] of Object.entries(incMap)) {
+      for (const fid of arr != null ? arr : [])
+        pushButtonEdge(keyId, fid, "include");
+    }
+    for (const [keyId, arr] of Object.entries(excMap)) {
+      for (const fid of arr != null ? arr : [])
+        pushButtonEdge(keyId, fid, "exclude");
+    }
+    return { nodes, edges };
+  }
+  cleanedProps() {
+    var _a, _b, _c, _d, _e;
+    const fieldIds = new Set(this.props.fields.map((f) => f.id));
+    const optionIds = /* @__PURE__ */ new Set();
+    this.optionOwnerById.forEach((_v, oid) => optionIds.add(oid));
+    const includedByTag = /* @__PURE__ */ new Set();
+    const excludedAnywhere = /* @__PURE__ */ new Set();
+    for (const t of this.props.filters) {
+      for (const id of (_a = t.includes) != null ? _a : []) includedByTag.add(id);
+      for (const id of (_b = t.excludes) != null ? _b : []) excludedAnywhere.add(id);
+    }
+    const incMap = (_c = this.props.includes_for_buttons) != null ? _c : {};
+    const excMap = (_d = this.props.excludes_for_buttons) != null ? _d : {};
+    const includedByButtons = /* @__PURE__ */ new Set();
+    const referencedKeys = /* @__PURE__ */ new Set();
+    const referencedOwnerFields = /* @__PURE__ */ new Set();
+    for (const [key, arr] of Object.entries(incMap)) {
+      referencedKeys.add(key);
+      const owner = this.optionOwnerById.get(key);
+      if (owner) referencedOwnerFields.add(owner.fieldId);
+      for (const fid of arr != null ? arr : []) {
+        includedByButtons.add(fid);
+      }
+    }
+    for (const [key, arr] of Object.entries(excMap)) {
+      referencedKeys.add(key);
+      const owner = this.optionOwnerById.get(key);
+      if (owner) referencedOwnerFields.add(owner.fieldId);
+      for (const fid of arr != null ? arr : []) {
+        void fid;
+      }
+    }
+    const boundIds = /* @__PURE__ */ new Set();
+    for (const f of this.props.fields) {
+      const b = f.bind_id;
+      if (Array.isArray(b)) b.forEach((id) => boundIds.add(id));
+      else if (typeof b === "string") boundIds.add(b);
+    }
+    const fields = this.props.fields.filter((f) => {
+      var _a2;
+      const isUtility = ((_a2 = f.pricing_role) != null ? _a2 : "base") === "utility";
+      if (!isUtility) return true;
+      const bound = !!f.bind_id;
+      const included = includedByTag.has(f.id) || includedByButtons.has(f.id);
+      const referenced = referencedOwnerFields.has(f.id) || referencedKeys.has(f.id);
+      const excluded = excludedAnywhere.has(f.id);
+      return bound || included || referenced || !excluded;
+    });
+    const allowedTargets = new Set(fields.map((f) => f.id));
+    const pruneButtons = (src) => {
+      if (!src) return void 0;
+      const out2 = {};
+      for (const [key, arr] of Object.entries(src)) {
+        const keyIsValid = optionIds.has(key) || fieldIds.has(key);
+        if (!keyIsValid) continue;
+        const cleaned = (arr != null ? arr : []).filter(
+          (fid) => allowedTargets.has(fid)
+        );
+        if (cleaned.length) out2[key] = Array.from(new Set(cleaned));
+      }
+      return Object.keys(out2).length ? out2 : void 0;
+    };
+    const includes_for_buttons = pruneButtons(
+      this.props.includes_for_buttons
+    );
+    const excludes_for_buttons = pruneButtons(
+      this.props.excludes_for_buttons
+    );
+    const out = {
+      filters: this.props.filters.slice(),
+      fields,
+      ...includes_for_buttons && { includes_for_buttons },
+      ...excludes_for_buttons && { excludes_for_buttons },
+      schema_version: (_e = this.props.schema_version) != null ? _e : "1.0",
+      // keep fallbacks & other maps as-is
+      ...this.props.fallbacks ? { fallbacks: this.props.fallbacks } : {}
+    };
+    return out;
+  }
+  errors() {
+    return validate(this.props, this.options);
+  }
+  visibleFields(tagId, selectedKeys) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    const props = this.props;
+    const tags = (_a = props.filters) != null ? _a : [];
+    const fields = (_b = props.fields) != null ? _b : [];
+    const tagById = new Map(tags.map((t) => [t.id, t]));
+    const tag = tagById.get(tagId);
+    if (!tag) return [];
+    const lineageDepth = /* @__PURE__ */ new Map();
+    {
+      const guard = /* @__PURE__ */ new Set();
+      let cur = tag;
+      let d = 0;
+      while (cur && !guard.has(cur.id)) {
+        lineageDepth.set(cur.id, d++);
+        guard.add(cur.id);
+        const parentId = cur.bind_id;
+        cur = parentId ? tagById.get(parentId) : void 0;
+      }
+    }
+    const isTagInLineage = (id) => lineageDepth.has(id);
+    const fieldById = new Map(fields.map((f) => [f.id, f]));
+    const optionOwnerFieldId = /* @__PURE__ */ new Map();
+    for (const f of fields) {
+      for (const o of (_c = f.options) != null ? _c : []) optionOwnerFieldId.set(o.id, f.id);
+    }
+    const ownerDepthForField = (f) => {
+      const b = f.bind_id;
+      if (!b) return void 0;
+      if (typeof b === "string") return lineageDepth.get(b);
+      let best = void 0;
+      for (const id of b) {
+        const d = lineageDepth.get(id);
+        if (d == null) continue;
+        if (best == null || d < best) best = d;
+      }
+      return best;
+    };
+    const ownerDepthForTrigger = (triggerId) => {
+      if (triggerId.startsWith("o:")) {
+        const fid = optionOwnerFieldId.get(triggerId);
+        if (!fid) return void 0;
+        const f2 = fieldById.get(fid);
+        if (!f2) return void 0;
+        return ownerDepthForField(f2);
+      }
+      const f = fieldById.get(triggerId);
+      if (!f || f.button !== true) return void 0;
+      return ownerDepthForField(f);
+    };
+    const tagInclude = new Set((_d = tag.includes) != null ? _d : []);
+    const tagExclude = new Set((_e = tag.excludes) != null ? _e : []);
+    const selected = new Set(
+      (_f = selectedKeys != null ? selectedKeys : this.options.selectedOptionKeys) != null ? _f : []
+    );
+    const incMap = (_g = props.includes_for_buttons) != null ? _g : {};
+    const excMap = (_h = props.excludes_for_buttons) != null ? _h : {};
+    const relevantTriggersInOrder = [];
+    for (const key of selected) {
+      const d = ownerDepthForTrigger(key);
+      if (d == null) continue;
+      relevantTriggersInOrder.push(key);
+    }
+    const visible = /* @__PURE__ */ new Set();
+    const isBoundToLineage = (f) => {
+      const b = f.bind_id;
+      if (!b) return false;
+      if (typeof b === "string") return isTagInLineage(b);
+      for (const id of b) if (isTagInLineage(id)) return true;
+      return false;
+    };
+    for (const f of fields) {
+      if (isBoundToLineage(f)) visible.add(f.id);
+      if (tagInclude.has(f.id)) visible.add(f.id);
+    }
+    for (const id of tagExclude) visible.delete(id);
+    const decide = /* @__PURE__ */ new Map();
+    const applyDecision = (fieldId, next) => {
+      const prev = decide.get(fieldId);
+      if (!prev) {
+        decide.set(fieldId, next);
+        return;
+      }
+      if (next.depth < prev.depth) {
+        decide.set(fieldId, next);
+        return;
+      }
+      if (next.depth > prev.depth) return;
+      if (prev.kind === "include" && next.kind === "exclude") {
+        decide.set(fieldId, next);
+      }
+    };
+    const revealedOrder = [];
+    const revealedSeen = /* @__PURE__ */ new Set();
+    for (const triggerId of relevantTriggersInOrder) {
+      const depth = ownerDepthForTrigger(triggerId);
+      if (depth == null) continue;
+      for (const id of (_i = incMap[triggerId]) != null ? _i : []) {
+        applyDecision(id, { depth, kind: "include" });
+        if (!revealedSeen.has(id)) {
+          revealedSeen.add(id);
+          revealedOrder.push(id);
+        }
+      }
+      for (const id of (_j = excMap[triggerId]) != null ? _j : []) {
+        applyDecision(id, { depth, kind: "exclude" });
+      }
+    }
+    for (const [fid, d] of decide) {
+      if (d.kind === "include") visible.add(fid);
+      else visible.delete(fid);
+    }
+    const base = fields.filter((f) => visible.has(f.id)).map((f) => f.id);
+    const order = (_k = props.order_for_tags) == null ? void 0 : _k[tagId];
+    if (order && order.length) {
+      const ordered = order.filter((fid) => visible.has(fid));
+      const orderedSet = new Set(ordered);
+      const rest2 = base.filter((fid) => !orderedSet.has(fid));
+      return [...ordered, ...rest2];
+    }
+    const promoted = revealedOrder.filter((fid) => visible.has(fid));
+    const promotedSet = new Set(promoted);
+    const rest = base.filter((fid) => !promotedSet.has(fid));
+    return [...promoted, ...rest];
+  }
+  /* ───── history ─────────────────────────────────────────────────────── */
+  undo() {
+    if (this.history.length === 0) return false;
+    const prev = this.history.pop();
+    this.future.push(structuredCloneSafe(this.props));
+    this.props = prev;
+    this.rebuildIndexes();
+    return true;
+  }
+  redo() {
+    if (this.future.length === 0) return false;
+    const next = this.future.pop();
+    this.pushHistory(this.props);
+    this.props = next;
+    this.rebuildIndexes();
+    return true;
+  }
+  /* ───── internals ──────────────────────────────────────────────────── */
+  rebuildIndexes() {
+    this.tagById.clear();
+    this.fieldById.clear();
+    this.optionOwnerById.clear();
+    for (const t of this.props.filters) this.tagById.set(t.id, t);
+    for (const f of this.props.fields) {
+      this.fieldById.set(f.id, f);
+      if (Array.isArray(f.options)) {
+        for (const o of f.options)
+          this.optionOwnerById.set(o.id, { fieldId: f.id });
+      }
+    }
+  }
+  pushHistory(state) {
+    if (!state || !state.filters.length && !state.fields.length) return;
+    this.history.push(structuredCloneSafe(state));
+    if (this.history.length > this.historyLimit) this.history.shift();
+  }
+};
+function structuredCloneSafe(v) {
+  if (typeof globalThis.structuredClone === "function") {
+    return globalThis.structuredClone(v);
+  }
+  return JSON.parse(JSON.stringify(v));
+}
+function toStringSet(v) {
+  if (!v) return /* @__PURE__ */ new Set();
+  if (v instanceof Set) return new Set(Array.from(v).map(String));
+  return new Set(v.map(String));
+}
+
+// src/core/fallback.ts
+var DEFAULT_SETTINGS = {
+  requireConstraintFit: true,
+  ratePolicy: { kind: "lte_primary" },
+  selectionStrategy: "priority",
+  mode: "strict"
+};
+function resolveServiceFallback(params) {
+  var _a, _b, _c, _d, _e;
+  const s = { ...DEFAULT_SETTINGS, ...(_a = params.settings) != null ? _a : {} };
+  const { primary, nodeId, tagId, services } = params;
+  const fb = (_b = params.fallbacks) != null ? _b : {};
+  const tried = [];
+  const lists = [];
+  if (nodeId && ((_c = fb.nodes) == null ? void 0 : _c[nodeId])) lists.push(fb.nodes[nodeId]);
+  if ((_d = fb.global) == null ? void 0 : _d[primary]) lists.push(fb.global[primary]);
+  const primaryRate = rateOf(services, primary);
+  for (const list of lists) {
+    for (const cand of list) {
+      if (tried.includes(cand)) continue;
+      tried.push(cand);
+      const candCap = (_e = services[Number(cand)]) != null ? _e : services[cand];
+      if (!candCap) continue;
+      if (!passesRate(s.ratePolicy, primaryRate, candCap.rate)) continue;
+      if (s.requireConstraintFit && tagId) {
+        const ok = satisfiesTagConstraints(tagId, params, candCap);
+        if (!ok) continue;
+      }
+      return cand;
+    }
+  }
+  return null;
+}
+function collectFailedFallbacks(props, services, settings) {
+  var _a, _b, _c;
+  const s = { ...DEFAULT_SETTINGS, ...settings != null ? settings : {} };
+  const out = [];
+  const fb = (_a = props.fallbacks) != null ? _a : {};
+  const primaryRate = (p) => rateOf(services, p);
+  for (const [nodeId, list] of Object.entries((_b = fb.nodes) != null ? _b : {})) {
+    const { primary, tagContexts } = primaryForNode(props, nodeId);
+    if (!primary) {
+      out.push({
+        scope: "node",
+        nodeId,
+        primary: "",
+        candidate: "",
+        reason: "no_primary"
+      });
+      continue;
+    }
+    for (const cand of list) {
+      const cap = getCap(services, cand);
+      if (!cap) {
+        out.push({
+          scope: "node",
+          nodeId,
+          primary,
+          candidate: cand,
+          reason: "unknown_service"
+        });
+        continue;
+      }
+      if (String(cand) === String(primary)) {
+        out.push({
+          scope: "node",
+          nodeId,
+          primary,
+          candidate: cand,
+          reason: "cycle"
+        });
+        continue;
+      }
+      if (!passesRate(s.ratePolicy, primaryRate(primary), cap.rate)) {
+        out.push({
+          scope: "node",
+          nodeId,
+          primary,
+          candidate: cand,
+          reason: "rate_violation"
+        });
+        continue;
+      }
+      if (tagContexts.length === 0) {
+        out.push({
+          scope: "node",
+          nodeId,
+          primary,
+          candidate: cand,
+          reason: "no_tag_context"
+        });
+        continue;
+      }
+      let anyPass = false;
+      let anyFail = false;
+      for (const tagId of tagContexts) {
+        const ok = s.requireConstraintFit ? satisfiesTagConstraints(tagId, { services, props }, cap) : true;
+        if (ok) anyPass = true;
+        else {
+          anyFail = true;
+          out.push({
+            scope: "node",
+            nodeId,
+            primary,
+            candidate: cand,
+            tagContext: tagId,
+            reason: "constraint_mismatch"
+          });
+        }
+      }
+      void anyPass;
+      void anyFail;
+    }
+  }
+  for (const [primary, list] of Object.entries((_c = fb.global) != null ? _c : {})) {
+    for (const cand of list) {
+      const cap = getCap(services, cand);
+      if (!cap) {
+        out.push({
+          scope: "global",
+          primary,
+          candidate: cand,
+          reason: "unknown_service"
+        });
+        continue;
+      }
+      if (String(cand) === String(primary)) {
+        out.push({
+          scope: "global",
+          primary,
+          candidate: cand,
+          reason: "cycle"
+        });
+        continue;
+      }
+      if (!passesRate(s.ratePolicy, primaryRate(primary), cap.rate)) {
+        out.push({
+          scope: "global",
+          primary,
+          candidate: cand,
+          reason: "rate_violation"
+        });
+      }
+    }
+  }
+  return out;
+}
+function rateOf(map, id) {
+  var _a;
+  if (id === void 0 || id === null) return void 0;
+  const c = getCap(map, id);
+  return (_a = c == null ? void 0 : c.rate) != null ? _a : void 0;
+}
+function passesRate(policy, primaryRate, candRate) {
+  if (typeof candRate !== "number" || !Number.isFinite(candRate))
+    return false;
+  if (typeof primaryRate !== "number" || !Number.isFinite(primaryRate))
+    return false;
+  switch (policy.kind) {
+    case "lte_primary":
+      return candRate <= primaryRate;
+    case "within_pct":
+      return candRate <= primaryRate * (1 + policy.pct / 100);
+    case "at_least_pct_lower":
+      return candRate <= primaryRate * (1 - policy.pct / 100);
+  }
+}
+function getCap(map, id) {
+  const direct = map[id];
+  if (direct) return direct;
+  const strKey = String(id);
+  const byStr = map[strKey];
+  if (byStr) return byStr;
+  const n = typeof id === "number" ? id : typeof id === "string" ? Number(id) : Number.NaN;
+  if (Number.isFinite(n)) {
+    const byNum = map[n];
+    if (byNum) return byNum;
+  }
+  return void 0;
+}
+function isCapFlagEnabled(cap, flagId) {
+  var _a, _b;
+  const fromFlags = (_b = (_a = cap.flags) == null ? void 0 : _a[flagId]) == null ? void 0 : _b.enabled;
+  if (fromFlags === true) return true;
+  if (fromFlags === false) return false;
+  const legacy = cap[flagId];
+  return legacy === true;
+}
+function satisfiesTagConstraints(tagId, ctx, cap) {
+  const tag = ctx.props.filters.find((t) => t.id === tagId);
+  const eff = tag == null ? void 0 : tag.constraints;
+  if (!eff) return true;
+  for (const [key, value] of Object.entries(eff)) {
+    if (value === true && !isCapFlagEnabled(cap, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+function primaryForNode(props, nodeId) {
+  const tag = props.filters.find((t) => t.id === nodeId);
+  if (tag) {
+    return { primary: tag.service_id, tagContexts: [tag.id] };
+  }
+  const field = props.fields.find(
+    (f) => Array.isArray(f.options) && f.options.some((o) => o.id === nodeId)
+  );
+  if (!field) return { tagContexts: [], reasonNoPrimary: "no_parent_field" };
+  const opt = field.options.find((o) => o.id === nodeId);
+  const contexts = bindIdsToArray(field.bind_id);
+  return { primary: opt.service_id, tagContexts: contexts };
+}
+function bindIdsToArray(bind) {
+  if (!bind) return [];
+  return Array.isArray(bind) ? bind.slice() : [bind];
+}
+function getEligibleFallbacks(params) {
+  var _a, _b, _c, _d, _e, _f;
+  const s = { ...DEFAULT_SETTINGS, ...(_a = params.settings) != null ? _a : {} };
+  const { primary, nodeId, tagId, services } = params;
+  const fb = (_b = params.fallbacks) != null ? _b : {};
+  const excludes = new Set(((_c = params.exclude) != null ? _c : []).map(String));
+  excludes.add(String(primary));
+  const unique = (_d = params.unique) != null ? _d : true;
+  const lists = [];
+  if (nodeId && ((_e = fb.nodes) == null ? void 0 : _e[nodeId])) lists.push(fb.nodes[nodeId]);
+  if ((_f = fb.global) == null ? void 0 : _f[primary]) lists.push(fb.global[primary]);
+  if (!lists.length) return [];
+  const primaryRate = rateOf(services, primary);
+  const seen = /* @__PURE__ */ new Set();
+  const eligible = [];
+  for (const list of lists) {
+    for (const cand of list) {
+      const key = String(cand);
+      if (excludes.has(key)) continue;
+      if (unique && seen.has(key)) continue;
+      seen.add(key);
+      const cap = getCap(services, cand);
+      if (!cap) continue;
+      if (!passesRate(s.ratePolicy, primaryRate, cap.rate)) continue;
+      if (s.requireConstraintFit && tagId) {
+        const ok = satisfiesTagConstraints(
+          tagId,
+          { props: params.props, services },
+          cap
+        );
+        if (!ok) continue;
+      }
+      eligible.push(cand);
+    }
+  }
+  if (s.selectionStrategy === "cheapest") {
+    eligible.sort((a, b) => {
+      var _a2, _b2;
+      const ra = (_a2 = rateOf(services, a)) != null ? _a2 : Infinity;
+      const rb = (_b2 = rateOf(services, b)) != null ? _b2 : Infinity;
+      return ra - rb;
+    });
+  }
+  if (typeof params.limit === "number" && params.limit >= 0) {
+    return eligible.slice(0, params.limit);
+  }
+  return eligible;
+}
+
+// src/core/rate-coherence.ts
+function validateRateCoherenceDeep(params) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const { builder, services, tagId } = params;
+  const ratePolicy = (_a = params.ratePolicy) != null ? _a : { kind: "lte_primary" };
+  const props = builder.getProps();
+  const fields = (_b = props.fields) != null ? _b : [];
+  const fieldById = new Map(fields.map((f) => [f.id, f]));
+  const tagById = new Map(((_c = props.filters) != null ? _c : []).map((t) => [t.id, t]));
+  const tag = tagById.get(tagId);
+  const baselineFieldIds = builder.visibleFields(tagId, []);
+  const baselineFields = baselineFieldIds.map((fid) => fieldById.get(fid)).filter(Boolean);
+  const anchors = [];
+  for (const f of baselineFields) {
+    if (!isButton(f)) continue;
+    if (Array.isArray(f.options) && f.options.length) {
+      for (const o of f.options) {
+        anchors.push({
+          kind: "option",
+          id: o.id,
+          fieldId: f.id,
+          label: (_d = o.label) != null ? _d : o.id,
+          service_id: numberOrUndefined(o.service_id)
+        });
+      }
+    } else {
+      anchors.push({
+        kind: "field",
+        id: f.id,
+        fieldId: f.id,
+        label: (_e = f.label) != null ? _e : f.id,
+        service_id: numberOrUndefined(f.service_id)
+      });
+    }
+  }
+  const diags = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const anchor of anchors) {
+    const selectedKeys = anchor.kind === "option" ? [`${anchor.fieldId}::${anchor.id}`] : [anchor.fieldId];
+    const vgFieldIds = builder.visibleFields(tagId, selectedKeys);
+    const vgFields = vgFieldIds.map((fid) => fieldById.get(fid)).filter(Boolean);
+    const baseCandidates = [];
+    for (const f of vgFields) {
+      if (!isButton(f)) continue;
+      if (Array.isArray(f.options) && f.options.length) {
+        for (const o of f.options) {
+          const sid = numberOrUndefined(o.service_id);
+          const role = normalizeRole(o.pricing_role, "base");
+          if (sid == null || role !== "base") continue;
+          const r = rateOf2(services, sid);
+          if (!isFiniteNumber2(r)) continue;
+          baseCandidates.push({
+            kind: "option",
+            id: o.id,
+            label: (_f = o.label) != null ? _f : o.id,
+            service_id: sid,
+            rate: r
+          });
+        }
+      } else {
+        const sid = numberOrUndefined(f.service_id);
+        const role = normalizeRole(f.pricing_role, "base");
+        if (sid == null || role !== "base") continue;
+        const r = rateOf2(services, sid);
+        if (!isFiniteNumber2(r)) continue;
+        baseCandidates.push({
+          kind: "field",
+          id: f.id,
+          label: (_g = f.label) != null ? _g : f.id,
+          service_id: sid,
+          rate: r
+        });
+      }
+    }
+    if (baseCandidates.length === 0) continue;
+    const anchorPrimary = anchor.service_id != null ? pickByServiceId(baseCandidates, anchor.service_id) : void 0;
+    const primary = anchorPrimary ? anchorPrimary : baseCandidates[0];
+    for (const cand of baseCandidates) {
+      if (sameService(primary, cand)) continue;
+      if (!rateOkWithPolicy(ratePolicy, cand.rate, primary.rate)) {
+        const key = dedupeKey(tagId, anchor, primary, cand, ratePolicy);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        diags.push({
+          scope: "visible_group",
+          tagId,
+          primary,
+          offender: {
+            kind: cand.kind,
+            id: cand.id,
+            label: cand.label,
+            service_id: cand.service_id,
+            rate: cand.rate
+          },
+          policy: ratePolicy.kind,
+          policyPct: "pct" in ratePolicy ? ratePolicy.pct : void 0,
+          message: explainRateMismatch(
+            ratePolicy,
+            primary.rate,
+            cand.rate,
+            describeLabel(tag)
+          ),
+          simulationAnchor: {
+            kind: anchor.kind,
+            id: anchor.id,
+            fieldId: anchor.fieldId,
+            label: anchor.label
+          }
+        });
+      }
+    }
+  }
+  return diags;
+}
+function isButton(f) {
+  if (f.button === true) return true;
+  return Array.isArray(f.options) && f.options.length > 0;
+}
+function normalizeRole(role, d) {
+  return role === "utility" || role === "base" ? role : d;
+}
+function numberOrUndefined(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+function isFiniteNumber2(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function rateOf2(map, id) {
+  var _a;
+  if (id === void 0 || id === null) return void 0;
+  const cap = (_a = map[Number(id)]) != null ? _a : map[id];
+  return cap == null ? void 0 : cap.rate;
+}
+function pickByServiceId(arr, sid) {
+  return arr.find((x) => x.service_id === sid);
+}
+function sameService(a, b) {
+  return a.service_id === b.service_id;
+}
+function rateOkWithPolicy(policy, candRate, primaryRate) {
+  var _a, _b;
+  const rp = policy != null ? policy : { kind: "lte_primary" };
+  switch (rp.kind) {
+    case "lte_primary":
+      return candRate <= primaryRate;
+    case "within_pct": {
+      const pct = Math.max(0, (_a = rp.pct) != null ? _a : 0);
+      return candRate <= primaryRate * (1 + pct / 100);
+    }
+    case "at_least_pct_lower": {
+      const pct = Math.max(0, (_b = rp.pct) != null ? _b : 0);
+      return candRate <= primaryRate * (1 - pct / 100);
+    }
+    default:
+      return candRate <= primaryRate;
+  }
+}
+function describeLabel(tag) {
+  var _a, _b;
+  const tagName = (_b = (_a = tag == null ? void 0 : tag.label) != null ? _a : tag == null ? void 0 : tag.id) != null ? _b : "tag";
+  return `${tagName}`;
+}
+function explainRateMismatch(policy, primary, candidate, where) {
+  switch (policy.kind) {
+    case "lte_primary":
+      return `Rate coherence failed (${where}): candidate ${candidate} must be \u2264 primary ${primary}.`;
+    case "within_pct":
+      return `Rate coherence failed (${where}): candidate ${candidate} must be within ${policy.pct}% of primary ${primary}.`;
+    case "at_least_pct_lower":
+      return `Rate coherence failed (${where}): candidate ${candidate} must be at least ${policy.pct}% lower than primary ${primary}.`;
+    default:
+      return `Rate coherence failed (${where}): candidate ${candidate} mismatches primary ${primary}.`;
+  }
+}
+function dedupeKey(tagId, anchor, primary, cand, rp) {
+  const rpKey = rp.kind + ("pct" in rp && typeof rp.pct === "number" ? `:${rp.pct}` : "");
+  return `${tagId}|${anchor.kind}:${anchor.id}|p${primary.service_id}|c${cand.service_id}:${cand.id}|${rpKey}`;
+}
+
+// src/core/tag-relations.ts
+var toId = (x) => typeof x === "string" ? x : x.id;
+var toBindList = (b) => {
+  if (!b) return [];
+  return typeof b === "string" ? [b] : [...b];
+};
+function createNodeIndex(builder) {
+  var _a, _b, _c, _d;
+  const props = builder.getProps();
+  const tags = (_a = props.filters) != null ? _a : [];
+  const fields = (_b = props.fields) != null ? _b : [];
+  const tagById = new Map(tags.map((t) => [t.id, t]));
+  const fieldById = new Map(fields.map((f) => [f.id, f]));
+  const optionById = /* @__PURE__ */ new Map();
+  const optionOwnerFieldId = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    for (const o of (_c = f.options) != null ? _c : []) {
+      optionById.set(o.id, o);
+      optionOwnerFieldId.set(o.id, f.id);
+    }
+  }
+  const parentById = /* @__PURE__ */ new Map();
+  const childrenById = /* @__PURE__ */ new Map();
+  for (const t of tags) {
+    parentById.set(t.id, t.bind_id);
+    if (t.bind_id) {
+      const arr = (_d = childrenById.get(t.bind_id)) != null ? _d : [];
+      arr.push(t.id);
+      childrenById.set(t.bind_id, arr);
+    }
+  }
+  const nodeCache = /* @__PURE__ */ new Map();
+  const tagNodeCache = /* @__PURE__ */ new Map();
+  const fieldNodeCache = /* @__PURE__ */ new Map();
+  const optionNodeCache = /* @__PURE__ */ new Map();
+  const tagAncestorsCache = /* @__PURE__ */ new Map();
+  const tagChildrenCache = /* @__PURE__ */ new Map();
+  const lineageIdsCache = /* @__PURE__ */ new Map();
+  const fieldBindIdsCache = /* @__PURE__ */ new Map();
+  const fieldOwnerTagsCache = /* @__PURE__ */ new Map();
+  const emptySet = Object.freeze(/* @__PURE__ */ new Set());
+  const isFieldBoundDirectToTag = (fieldId, tagId) => {
+    const field = fieldById.get(fieldId);
+    if (!field) return false;
+    const bind = field.bind_id;
+    if (!bind) return false;
+    if (typeof bind === "string") return bind === tagId;
+    return bind.includes(tagId);
+  };
+  const resolveDescendants = (id, includes, tagId, forceSimple) => {
+    if (!tagId || forceSimple) {
+      const results2 = [];
+      for (const incId of includes) {
+        const node = getField(incId);
+        if (node) results2.push(node);
+      }
+      return Object.freeze(results2);
+    }
+    const results = [];
+    const visible = builder.visibleFields(tagId, [id]);
+    for (const fieldId of visible) {
+      const node = getField(fieldId);
+      if (!node) continue;
+      const explicit = includes.has(fieldId) || isFieldBoundDirectToTag(fieldId, tagId);
+      results.push(explicit ? node : { ...node, isInherited: true });
+    }
+    return Object.freeze(results);
+  };
+  const lineageIds = (tagId) => {
+    const cached = lineageIdsCache.get(tagId);
+    if (cached) return cached;
+    const out = /* @__PURE__ */ new Set();
+    const guard = /* @__PURE__ */ new Set();
+    let cur = tagId;
+    while (cur && !guard.has(cur)) {
+      out.add(cur);
+      guard.add(cur);
+      cur = parentById.get(cur);
+    }
+    lineageIdsCache.set(tagId, out);
+    return out;
+  };
+  const pathBetween = (fromId, toId2) => {
+    if (fromId === toId2) return [fromId];
+    const guard = /* @__PURE__ */ new Set();
+    const stack = [];
+    let cur = toId2;
+    while (cur && !guard.has(cur)) {
+      stack.push(cur);
+      if (cur === fromId) return stack.reverse();
+      guard.add(cur);
+      cur = parentById.get(cur);
+    }
+    return null;
+  };
+  const relationBetween = (baseId, otherId) => {
+    if (baseId === otherId)
+      return { kind: "self", path: [baseId], index: 0, direct: false };
+    const down = pathBetween(baseId, otherId);
+    if (down)
+      return {
+        kind: "descendant",
+        path: down,
+        index: down.length - 1,
+        direct: down.length === 2
+      };
+    const up = pathBetween(otherId, baseId);
+    if (up) {
+      const p = up.slice().reverse();
+      return {
+        kind: "ancestor",
+        path: p,
+        index: p.length - 1,
+        direct: p.length === 2
+      };
+    }
+    return { kind: "unrelated", path: [], index: -1, direct: false };
+  };
+  const makeAncestry = (selfOwnerTagIds) => {
+    return (baseTag) => {
+      const baseId = toId(baseTag);
+      const hits = [];
+      for (const ownerId of selfOwnerTagIds) {
+        const owner = getTag(ownerId);
+        if (!owner) continue;
+        const rel = relationBetween(baseId, ownerId);
+        hits.push({
+          kind: rel.kind,
+          node: owner,
+          index: rel.index,
+          direct: rel.direct,
+          path: rel.path
+        });
+      }
+      return hits;
+    };
+  };
+  const makeAncestryFns = (ancestryFn) => ({
+    ancestry: ancestryFn,
+    isAncestorOf(baseTag) {
+      return ancestryFn(baseTag).some((h) => h.kind === "ancestor");
+    },
+    isDescendantOf(baseTag) {
+      return ancestryFn(baseTag).some((h) => h.kind === "descendant");
+    },
+    isWithin(baseTag) {
+      return ancestryFn(baseTag).some(
+        (h) => h.kind === "self" || h.kind === "descendant"
+      );
+    }
+  });
+  const getTag = (id) => {
+    var _a2, _b2;
+    const cached = tagNodeCache.get(id);
+    if (cached) return cached;
+    const raw = tagById.get(id);
+    if (!raw) return void 0;
+    const includes = Object.freeze(new Set((_a2 = raw.includes) != null ? _a2 : []));
+    const excludes = Object.freeze(new Set((_b2 = raw.excludes) != null ? _b2 : []));
+    const ancestryFn = makeAncestry([id]);
+    const node = {
+      kind: "tag",
+      id,
+      raw,
+      includes,
+      excludes,
+      ...makeAncestryFns(ancestryFn),
+      parent() {
+        const pid = parentById.get(id);
+        return pid ? getTag(pid) : void 0;
+      },
+      children() {
+        var _a3;
+        const cachedChildren = tagChildrenCache.get(id);
+        if (cachedChildren) return cachedChildren;
+        const childIds = (_a3 = childrenById.get(id)) != null ? _a3 : [];
+        const arr = childIds.map((cid) => getTag(cid)).filter(Boolean);
+        const frozen = Object.freeze(arr);
+        tagChildrenCache.set(id, frozen);
+        return frozen;
+      },
+      ancestors() {
+        var _a3;
+        const cachedAnc = tagAncestorsCache.get(id);
+        if (cachedAnc) return cachedAnc;
+        const rows = [];
+        const guard = /* @__PURE__ */ new Set();
+        let cur = parentById.get(id);
+        let index = 1;
+        while (cur && !guard.has(cur)) {
+          const n = getTag(cur);
+          if (!n) break;
+          const p = (_a3 = pathBetween(id, cur)) != null ? _a3 : [id, cur];
+          rows.push({ node: n, direct: index === 1, index, path: p });
+          guard.add(cur);
+          cur = parentById.get(cur);
+          index++;
+        }
+        const frozen = Object.freeze(rows);
+        tagAncestorsCache.set(id, frozen);
+        return frozen;
+      },
+      pathTo(descendant) {
+        const to = toId(descendant);
+        return pathBetween(id, to);
+      },
+      isBoundTo(tagId) {
+        const tid = toId(tagId);
+        if (tid === id) return true;
+        return parentById.get(id) === tid;
+      },
+      getDescendant(descendantId) {
+        return this.getDescendants().find((item) => item.id == descendantId);
+      },
+      getDescendants() {
+        const results = [];
+        const visible = builder.visibleFields(id);
+        for (const fieldId of visible) {
+          const node2 = getField(fieldId);
+          if (!node2) continue;
+          const explicit = includes.has(fieldId) || isFieldBoundDirectToTag(fieldId, id);
+          results.push(explicit ? node2 : { ...node2, isInherited: true });
+        }
+        return Object.freeze(results);
+      }
+    };
+    tagNodeCache.set(id, node);
+    nodeCache.set(id, node);
+    return node;
+  };
+  const getField = (id) => {
+    var _a2, _b2, _c2, _d2;
+    const cached = fieldNodeCache.get(id);
+    if (cached) return cached;
+    const raw = fieldById.get(id);
+    if (!raw) return void 0;
+    const isButton2 = raw.button === true;
+    const includes = isButton2 ? Object.freeze(new Set((_b2 = (_a2 = props.includes_for_buttons) == null ? void 0 : _a2[id]) != null ? _b2 : [])) : emptySet;
+    const excludes = isButton2 ? Object.freeze(new Set((_d2 = (_c2 = props.excludes_for_buttons) == null ? void 0 : _c2[id]) != null ? _d2 : [])) : emptySet;
+    const bindIds = () => {
+      const cachedBind = fieldBindIdsCache.get(id);
+      if (cachedBind) return cachedBind;
+      const res = Object.freeze(toBindList(raw.bind_id));
+      fieldBindIdsCache.set(id, res);
+      return res;
+    };
+    const ancestryFn = makeAncestry(bindIds());
+    const node = {
+      kind: "field",
+      id,
+      raw,
+      includes,
+      excludes,
+      ...makeAncestryFns(ancestryFn),
+      bindIds,
+      ownerTags() {
+        const cachedOwners = fieldOwnerTagsCache.get(id);
+        if (cachedOwners) return cachedOwners;
+        const owners = bindIds().map((tid) => getTag(tid)).filter(Boolean);
+        const frozen = Object.freeze(owners);
+        fieldOwnerTagsCache.set(id, frozen);
+        return frozen;
+      },
+      isBoundTo(tagId) {
+        const tid = toId(tagId);
+        const lin = lineageIds(tid);
+        for (const b of bindIds()) if (lin.has(b)) return true;
+        return false;
+      },
+      getDescendant(descendantId, context) {
+        return this.getDescendants(context).find((item) => item.id == descendantId);
+      },
+      getDescendants(tagId) {
+        return resolveDescendants(id, includes, tagId, !isButton2);
+      }
+    };
+    fieldNodeCache.set(id, node);
+    nodeCache.set(id, node);
+    return node;
+  };
+  const getOption = (id) => {
+    var _a2, _b2, _c2, _d2;
+    const cached = optionNodeCache.get(id);
+    if (cached) return cached;
+    const raw = optionById.get(id);
+    const ownerFieldId = optionOwnerFieldId.get(id);
+    if (!raw || !ownerFieldId) return void 0;
+    const owner = getField(ownerFieldId);
+    if (!owner) return void 0;
+    const includes = Object.freeze(
+      new Set((_b2 = (_a2 = props.includes_for_buttons) == null ? void 0 : _a2[id]) != null ? _b2 : [])
+    );
+    const excludes = Object.freeze(
+      new Set((_d2 = (_c2 = props.excludes_for_buttons) == null ? void 0 : _c2[id]) != null ? _d2 : [])
+    );
+    const node = {
+      kind: "option",
+      id,
+      raw,
+      includes,
+      excludes,
+      ...makeAncestryFns((baseTag) => owner.ancestry(baseTag)),
+      field() {
+        return owner;
+      },
+      ownerTags() {
+        return owner.ownerTags();
+      },
+      isBoundTo(tagId) {
+        return owner.isBoundTo(tagId);
+      },
+      getDescendant(descendantId, context) {
+        return this.getDescendants(context).find((item) => item.id == descendantId);
+      },
+      getDescendants(tagId) {
+        return resolveDescendants(id, includes, tagId);
+      }
+    };
+    optionNodeCache.set(id, node);
+    nodeCache.set(id, node);
+    return node;
+  };
+  const getNode = (input) => {
+    var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i;
+    if (typeof input !== "string") {
+      if ("bind_id" in input && !("type" in input))
+        return (_a2 = getTag(input.id)) != null ? _a2 : mkUnknown(input.id);
+      if ("type" in input)
+        return (_b2 = getField(input.id)) != null ? _b2 : mkUnknown(input.id);
+      return (_c2 = getOption(input.id)) != null ? _c2 : mkUnknown(input.id);
+    }
+    const cached = nodeCache.get(input);
+    if (cached) return cached;
+    const id = input;
+    if (id.startsWith("t:")) return (_d2 = getTag(id)) != null ? _d2 : mkUnknown(id);
+    if (id.startsWith("f:")) return (_e = getField(id)) != null ? _e : mkUnknown(id);
+    if (id.startsWith("o:")) return (_f = getOption(id)) != null ? _f : mkUnknown(id);
+    return (_i = (_h = (_g = getTag(id)) != null ? _g : getField(id)) != null ? _h : getOption(id)) != null ? _i : mkUnknown(id);
+  };
+  const mkUnknown = (id) => {
+    const u = {
+      kind: "unknown",
+      id,
+      includes: emptySet,
+      excludes: emptySet,
+      ...makeAncestryFns(() => [])
+    };
+    nodeCache.set(id, u);
+    return u;
+  };
+  return {
+    getNode,
+    getTag,
+    getField,
+    getOption
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectFailedFallbacks,
+  createBuilder,
+  createNodeIndex,
+  getEligibleFallbacks,
+  normalise,
+  resolveServiceFallback,
+  validate,
+  validateRateCoherenceDeep
+});
+//# sourceMappingURL=index.cjs.map