@timeax/digital-service-engine 0.0.1 → 0.0.2

package/dist/core/index.js

@@ -280,11 +280,6 @@ 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(".");
@@ -370,33 +365,217 @@ function withAffected(details, ids) {
   return { ...details != null ? details : {}, affectedIds: ids };
 }
 
+// src/core/node-map.ts
+function buildNodeMap(props) {
+  var _a, _b, _c;
+  const map = /* @__PURE__ */ new Map();
+  for (const t of (_a = props.filters) != null ? _a : []) {
+    if (!map.has(t.id)) map.set(t.id, { kind: "tag", id: t.id, node: t });
+  }
+  for (const f of (_b = props.fields) != null ? _b : []) {
+    if (!map.has(f.id)) map.set(f.id, { kind: "field", id: f.id, node: f });
+    for (const o of (_c = f.options) != null ? _c : []) {
+      if (!map.has(o.id))
+        map.set(o.id, {
+          kind: "option",
+          id: o.id,
+          node: o,
+          fieldId: f.id
+        });
+    }
+  }
+  return map;
+}
+function resolveTrigger(trigger, nodeMap) {
+  const idx = trigger.indexOf("::");
+  if (idx !== -1) {
+    const fieldId = trigger.slice(0, idx);
+    const optionId = trigger.slice(idx + 2);
+    return { kind: "composite", triggerKey: trigger, fieldId, optionId };
+  }
+  const direct = nodeMap.get(trigger);
+  if (!direct) return void 0;
+  if (direct.kind === "option") {
+    return {
+      kind: "option",
+      triggerKey: trigger,
+      id: direct.id,
+      fieldId: direct.fieldId
+    };
+  }
+  return { kind: direct.kind, triggerKey: trigger, id: direct.id };
+}
+
+// src/core/visibility.ts
+function visibleFieldIdsUnder(props, tagId, opts = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  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 nodeMap = buildNodeMap(props);
+  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 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 ownerDepthForTriggerKey = (triggerKey) => {
+    const t = resolveTrigger(triggerKey, nodeMap);
+    if (!t) return void 0;
+    if (t.kind === "composite") {
+      const f = fieldById.get(t.fieldId);
+      if (!f) return void 0;
+      return ownerDepthForField(f);
+    }
+    if (t.kind === "field") {
+      const f = fieldById.get(t.id);
+      if (!f || f.button !== true) return void 0;
+      return ownerDepthForField(f);
+    }
+    if (t.kind === "option") {
+      const f = t.fieldId ? fieldById.get(t.fieldId) : void 0;
+      if (!f) return void 0;
+      return ownerDepthForField(f);
+    }
+    return void 0;
+  };
+  const tagInclude = new Set((_c = tag.includes) != null ? _c : []);
+  const tagExclude = new Set((_d = tag.excludes) != null ? _d : []);
+  const selected = (_e = opts.selectedKeys) != null ? _e : /* @__PURE__ */ new Set();
+  const incMap = (_f = props.includes_for_buttons) != null ? _f : {};
+  const excMap = (_g = props.excludes_for_buttons) != null ? _g : {};
+  const relevantTriggersInOrder = [];
+  for (const key of selected) {
+    const d = ownerDepthForTriggerKey(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) return void decide.set(fieldId, next);
+    if (next.depth < prev.depth) return void decide.set(fieldId, next);
+    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 triggerKey of relevantTriggersInOrder) {
+    const depth = ownerDepthForTriggerKey(triggerKey);
+    if (depth == null) continue;
+    for (const id of (_h = incMap[triggerKey]) != null ? _h : []) {
+      applyDecision(id, { depth, kind: "include" });
+      if (!revealedSeen.has(id)) {
+        revealedSeen.add(id);
+        revealedOrder.push(id);
+      }
+    }
+    for (const id of (_i = excMap[triggerKey]) != null ? _i : []) {
+      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 = (_j = props.order_for_tags) == null ? void 0 : _j[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];
+}
+function visibleFieldsUnder(props, tagId, opts = {}) {
+  var _a;
+  const ids = visibleFieldIdsUnder(props, tagId, opts);
+  const fieldById = new Map(((_a = props.fields) != null ? _a : []).map((f) => [f.id, f]));
+  return ids.map((id) => fieldById.get(id)).filter(Boolean);
+}
+
 // 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());
+    return visibleFieldsUnder(v.props, tagId, {
+      selectedKeys: v.selectedKeys
+    });
   };
 }
-function validateVisibility(v) {
+function stableKeyOfSelection(keys) {
+  return Array.from(keys).sort().join("|");
+}
+function resolveRootTags(tags) {
+  const roots = tags.filter((t) => !t.bind_id);
+  return roots.length ? roots : tags.slice(0, 1);
+}
+function isEffectfulTrigger(v, trigger) {
+  var _a, _b, _c, _d, _e, _f;
+  const inc = (_a = v.props.includes_for_buttons) != null ? _a : {};
+  const exc = (_b = v.props.excludes_for_buttons) != null ? _b : {};
+  return ((_d = (_c = inc[trigger]) == null ? void 0 : _c.length) != null ? _d : 0) > 0 || ((_f = (_e = exc[trigger]) == null ? void 0 : _e.length) != null ? _f : 0) > 0;
+}
+function collectSelectableTriggersInContext(v, tagId, selectedKeys, onlyEffectful) {
+  var _a;
+  const visible = visibleFieldsUnder(v.props, tagId, {
+    selectedKeys
+  });
+  const triggers = [];
+  for (const f of visible) {
+    if (f.button === true) {
+      const t = f.id;
+      if (!onlyEffectful || isEffectfulTrigger(v, t)) triggers.push(t);
+    }
+    for (const o of (_a = f.options) != null ? _a : []) {
+      const t = `${f.id}::${o.id}`;
+      if (!onlyEffectful || isEffectfulTrigger(v, t)) triggers.push(t);
+    }
+  }
+  triggers.sort();
+  return triggers;
+}
+function runVisibilityRulesOnce(v) {
   var _a, _b, _c, _d, _e;
   for (const t of v.tags) {
     const visible = v.fieldsVisibleUnder(t.id);
@@ -471,12 +650,85 @@ function validateVisibility(v) {
     }
   }
 }
+function dedupeErrorsInPlace(v, startIndex) {
+  const seen = /* @__PURE__ */ new Set();
+  const keyOfErr = (e) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const tagId = (_e = (_d = (_a = e == null ? void 0 : e.details) == null ? void 0 : _a.tagId) != null ? _d : (_c = (_b = e == null ? void 0 : e.details) == null ? void 0 : _b.affected) == null ? void 0 : _c.tagId) != null ? _e : "";
+    const other = (_g = (_f = e == null ? void 0 : e.details) == null ? void 0 : _f.other) != null ? _g : "";
+    return `${(_h = e == null ? void 0 : e.code) != null ? _h : ""}::${(_i = e == null ? void 0 : e.nodeId) != null ? _i : ""}::${tagId}::${other}::${(_j = e == null ? void 0 : e.message) != null ? _j : ""}`;
+  };
+  const kept = [];
+  for (let i = startIndex; i < v.errors.length; i++) {
+    const e = v.errors[i];
+    const k = keyOfErr(e);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    kept.push(e);
+  }
+  v.errors.splice(startIndex, v.errors.length - startIndex, ...kept);
+}
+function validateVisibility(v, options = {}) {
+  var _a, _b, _c;
+  const simulate = options.simulate === true;
+  if (!simulate) {
+    runVisibilityRulesOnce(v);
+    return;
+  }
+  const maxStates = Math.max(1, (_a = options.maxStates) != null ? _a : 500);
+  const maxDepth = Math.max(0, (_b = options.maxDepth) != null ? _b : 6);
+  const onlyEffectful = options.onlyEffectfulTriggers !== false;
+  const roots = resolveRootTags(v.tags);
+  const rootTags = options.simulateAllRoots ? roots : roots.slice(0, 1);
+  const originalSelected = new Set((_c = v.selectedKeys) != null ? _c : []);
+  const errorsStart = v.errors.length;
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [];
+  for (const rt of rootTags) {
+    stack.push({
+      rootTagId: rt.id,
+      selected: new Set(originalSelected),
+      depth: 0
+    });
+  }
+  let validatedStates = 0;
+  while (stack.length) {
+    if (validatedStates >= maxStates) break;
+    const state = stack.pop();
+    const sig = stableKeyOfSelection(state.selected);
+    if (visited.has(sig)) continue;
+    visited.add(sig);
+    v.selectedKeys = state.selected;
+    validatedStates++;
+    runVisibilityRulesOnce(v);
+    if (state.depth >= maxDepth) continue;
+    const triggers = collectSelectableTriggersInContext(
+      v,
+      state.rootTagId,
+      state.selected,
+      onlyEffectful
+    );
+    for (let i = triggers.length - 1; i >= 0; i--) {
+      const trig = triggers[i];
+      if (state.selected.has(trig)) continue;
+      const next = new Set(state.selected);
+      next.add(trig);
+      stack.push({
+        rootTagId: state.rootTagId,
+        selected: next,
+        depth: state.depth + 1
+      });
+    }
+  }
+  v.selectedKeys = originalSelected;
+  dedupeErrorsInPlace(v, errorsStart);
+}
 
 // src/core/validate/steps/structure.ts
 function validateStructure(v) {
   const tags = v.tags;
   const fields = v.fields;
-  if (!tags.some((t) => t.id === "root")) {
+  if (!tags.some((t) => t.id === "t:root")) {
     v.errors.push({
       code: "root_missing",
       severity: "error",
@@ -666,58 +918,91 @@ function validateIdentity(v) {
 }
 
 // src/core/validate/steps/option-maps.ts
+function parseFieldOptionKey(key) {
+  const idx = key.indexOf("::");
+  if (idx === -1) return null;
+  const fieldId = key.slice(0, idx).trim();
+  const optionId = key.slice(idx + 2).trim();
+  if (!fieldId || !optionId) return null;
+  return { fieldId, optionId };
+}
+function hasOption(v, fid, oid) {
+  var _a;
+  const f = v.fieldById.get(fid);
+  if (!f) return false;
+  return !!((_a = f.options) != null ? _a : []).find((o) => o.id === oid);
+}
 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 trigger-map key "${key}". Expected a known node id (option or button-field), or "fieldId::optionId" pointing to an existing option.`;
+  const validateTriggerKey = (key) => {
+    const ref = v.nodeMap.get(key);
+    if (ref) {
+      if (ref.kind === "option") {
+        return {
+          ok: true,
+          nodeId: ref.fieldId,
+          affected: [ref.fieldId, ref.id]
+        };
+      }
+      if (ref.kind === "field") {
+        const isButton2 = ref.node.button === true;
+        if (!isButton2)
+          return { ok: false, nodeId: ref.id, affected: [ref.id] };
+        return { ok: true, nodeId: ref.id, affected: [ref.id] };
+      }
+      return { ok: false, nodeId: ref.id, affected: [ref.id] };
+    }
+    const p = parseFieldOptionKey(key);
+    if (!p) return { ok: false };
+    if (!hasOption(v, p.fieldId, p.optionId))
+      return {
+        ok: false,
+        nodeId: p.fieldId,
+        affected: [p.fieldId, p.optionId]
+      };
+    return {
+      ok: true,
+      nodeId: p.fieldId,
+      affected: [p.fieldId, p.optionId]
+    };
   };
-  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)) {
+    const r = validateTriggerKey(k);
+    if (!r.ok) {
       v.errors.push({
         code: "bad_option_key",
         severity: "error",
         message: badKeyMessage(k),
-        details: { key: k }
+        nodeId: r.nodeId,
+        details: withAffected({ key: k }, r.affected)
       });
     }
   }
   for (const k of Object.keys(excMap)) {
-    const p = parseKey(k);
-    if (!p || !hasOption(p.fieldId, p.optionId)) {
+    const r = validateTriggerKey(k);
+    if (!r.ok) {
       v.errors.push({
         code: "bad_option_key",
         severity: "error",
         message: badKeyMessage(k),
-        details: { key: k }
+        nodeId: r.nodeId,
+        details: withAffected({ key: k }, r.affected)
       });
     }
   }
   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)
-      });
-    }
+    if (!(k in excMap)) continue;
+    const r = validateTriggerKey(k);
+    v.errors.push({
+      code: "option_include_exclude_conflict",
+      severity: "error",
+      message: `Trigger-map key "${k}" appears in both includes_for_buttons and excludes_for_buttons.`,
+      nodeId: r.nodeId,
+      details: withAffected({ key: k }, r.affected)
+    });
   }
 }
 
@@ -1622,8 +1907,23 @@ function applyPolicies(errors, props, serviceMap, policies, fieldsVisibleUnder,
 }
 
 // src/core/validate/index.ts
+function readVisibilitySimOpts(ctx) {
+  const c = ctx;
+  const simulate = c.simulateVisibility === true || c.visibilitySimulate === true || c.simulate === true;
+  const maxStates = typeof c.maxVisibilityStates === "number" ? c.maxVisibilityStates : typeof c.visibilityMaxStates === "number" ? c.visibilityMaxStates : typeof c.maxStates === "number" ? c.maxStates : void 0;
+  const maxDepth = typeof c.maxVisibilityDepth === "number" ? c.maxVisibilityDepth : typeof c.visibilityMaxDepth === "number" ? c.visibilityMaxDepth : typeof c.maxDepth === "number" ? c.maxDepth : void 0;
+  const simulateAllRoots = c.simulateAllRoots === true || c.visibilitySimulateAllRoots === true;
+  const onlyEffectfulTriggers = c.onlyEffectfulTriggers === false ? false : c.visibilityOnlyEffectfulTriggers !== false;
+  return {
+    simulate,
+    maxStates,
+    maxDepth,
+    simulateAllRoots,
+    onlyEffectfulTriggers
+  };
+}
 function validate(props, ctx = {}) {
-  var _a, _b;
+  var _a, _b, _c;
   const errors = [];
   const serviceMap = (_a = ctx.serviceMap) != null ? _a : {};
   const selectedKeys = new Set(
@@ -1637,6 +1937,7 @@ function validate(props, ctx = {}) {
   for (const f of fields) fieldById.set(f.id, f);
   const v = {
     props,
+    nodeMap: (_c = ctx.nodeMap) != null ? _c : buildNodeMap(props),
     options: ctx,
     errors,
     serviceMap,
@@ -1651,7 +1952,8 @@ function validate(props, ctx = {}) {
   validateIdentity(v);
   validateOptionMaps(v);
   v.fieldsVisibleUnder = createFieldsVisibleUnder(v);
-  validateVisibility(v);
+  const visSim = readVisibilitySimOpts(ctx);
+  validateVisibility(v, visSim);
   applyPolicies(
     v.errors,
     v.props,
@@ -1670,6 +1972,17 @@ function validate(props, ctx = {}) {
   validateFallbacks(v);
   return v.errors;
 }
+async function validateAsync(props, ctx = {}) {
+  await Promise.resolve();
+  if (typeof requestAnimationFrame === "function") {
+    await new Promise(
+      (resolve) => requestAnimationFrame(() => resolve())
+    );
+  } else {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  return validate(props, ctx);
+}
 
 // src/core/builder.ts
 function createBuilder(opts = {}) {
@@ -1687,11 +2000,21 @@ var BuilderImpl = class {
     this.optionOwnerById = /* @__PURE__ */ new Map();
     this.history = [];
     this.future = [];
+    this._nodemap = null;
     var _a;
     this.options = { ...opts };
     this.historyLimit = (_a = opts.historyLimit) != null ? _a : 50;
   }
   /* ───── lifecycle ─────────────────────────────────────────────────────── */
+  isTagId(id) {
+    return this.tagById.has(id);
+  }
+  isFieldId(id) {
+    return this.fieldById.has(id);
+  }
+  isOptionId(id) {
+    return this.optionOwnerById.has(id);
+  }
   load(raw) {
     const next = normalise(raw, {
       defaultPricingRole: "base",
@@ -1911,129 +2234,16 @@ var BuilderImpl = class {
     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];
+    var _a;
+    return visibleFieldIdsUnder(this.props, tagId, {
+      selectedKeys: new Set(
+        (_a = selectedKeys != null ? selectedKeys : this.options.selectedOptionKeys) != null ? _a : []
+      )
+    });
+  }
+  getNodeMap() {
+    if (!this._nodemap) this._nodemap = buildNodeMap(this.getProps());
+    return this._nodemap;
   }
   /* ───── history ─────────────────────────────────────────────────────── */
   undo() {
@@ -2057,6 +2267,7 @@ var BuilderImpl = class {
     this.tagById.clear();
     this.fieldById.clear();
     this.optionOwnerById.clear();
+    this._nodemap = null;
     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);
@@ -2538,6 +2749,7 @@ var toBindList = (b) => {
 function createNodeIndex(builder) {
   var _a, _b, _c, _d;
   const props = builder.getProps();
+  const nodeMap = builder.getNodeMap();
   const tags = (_a = props.filters) != null ? _a : [];
   const fields = (_b = props.fields) != null ? _b : [];
   const tagById = new Map(tags.map((t) => [t.id, t]));
@@ -2741,7 +2953,9 @@ function createNodeIndex(builder) {
         return parentById.get(id) === tid;
       },
       getDescendant(descendantId) {
-        return this.getDescendants().find((item) => item.id == descendantId);
+        return this.getDescendants().find(
+          (item) => item.id == descendantId
+        );
       },
       getDescendants() {
         const results = [];
@@ -2750,7 +2964,9 @@ function createNodeIndex(builder) {
           const node2 = getField(fieldId);
           if (!node2) continue;
           const explicit = includes.has(fieldId) || isFieldBoundDirectToTag(fieldId, id);
-          results.push(explicit ? node2 : { ...node2, isInherited: true });
+          results.push(
+            explicit ? node2 : { ...node2, isInherited: true }
+          );
         }
         return Object.freeze(results);
       }
@@ -2799,7 +3015,9 @@ function createNodeIndex(builder) {
         return false;
       },
       getDescendant(descendantId, context) {
-        return this.getDescendants(context).find((item) => item.id == descendantId);
+        return this.getDescendants(context).find(
+          (item) => item.id == descendantId
+        );
       },
       getDescendants(tagId) {
         return resolveDescendants(id, includes, tagId, !isButton2);
@@ -2841,7 +3059,9 @@ function createNodeIndex(builder) {
         return owner.isBoundTo(tagId);
       },
       getDescendant(descendantId, context) {
-        return this.getDescendants(context).find((item) => item.id == descendantId);
+        return this.getDescendants(context).find(
+          (item) => item.id == descendantId
+        );
       },
       getDescendants(tagId) {
         return resolveDescendants(id, includes, tagId);
@@ -2852,7 +3072,7 @@ function createNodeIndex(builder) {
     return node;
   };
   const getNode = (input) => {
-    var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i;
+    var _a2, _b2, _c2, _d2, _e;
     if (typeof input !== "string") {
       if ("bind_id" in input && !("type" in input))
         return (_a2 = getTag(input.id)) != null ? _a2 : mkUnknown(input.id);
@@ -2862,11 +3082,7 @@ function createNodeIndex(builder) {
     }
     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);
+    return (_e = (_d2 = nodeMap.get(input)) == null ? void 0 : _d2.node) != null ? _e : mkUnknown(input);
   };
   const mkUnknown = (id) => {
     const u = {
@@ -2886,7 +3102,692 @@ function createNodeIndex(builder) {
     getOption
   };
 }
+
+// src/utils/prune-fallbacks.ts
+function pruneInvalidNodeFallbacks(props, services, settings) {
+  var _a, _b;
+  const fb = props.fallbacks;
+  if (!(fb == null ? void 0 : fb.nodes) || Object.keys(fb.nodes).length === 0) {
+    return { props, removed: [] };
+  }
+  const nodeContexts = /* @__PURE__ */ new Map();
+  const nodePrimary = /* @__PURE__ */ new Map();
+  for (const nodeId of Object.keys(fb.nodes)) {
+    const tag = props.filters.find((t) => t.id === nodeId);
+    if (tag) {
+      nodeContexts.set(nodeId, [tag.id]);
+      nodePrimary.set(nodeId, tag.service_id);
+      continue;
+    }
+    const field = props.fields.find((f) => Array.isArray(f.options) && f.options.some((o) => o.id === nodeId));
+    if (field) {
+      const contexts = toBindArray(field.bind_id);
+      nodeContexts.set(nodeId, contexts);
+      const opt = field.options.find((o) => o.id === nodeId);
+      nodePrimary.set(nodeId, opt.service_id);
+      continue;
+    }
+    nodeContexts.set(nodeId, []);
+    nodePrimary.set(nodeId, void 0);
+  }
+  const diags = collectFailedFallbacks(props, services, { ...settings, mode: "dev" });
+  const failuresByPair = /* @__PURE__ */ new Map();
+  const totalContextsByNode = /* @__PURE__ */ new Map();
+  for (const [nodeId, ctxs] of nodeContexts.entries()) {
+    totalContextsByNode.set(nodeId, Math.max(1, ctxs.length));
+  }
+  for (const d of diags) {
+    if (d.scope !== "node") continue;
+    const key = `${d.nodeId}::${String(d.candidate)}`;
+    let rec = failuresByPair.get(key);
+    if (!rec) {
+      rec = { reasons: /* @__PURE__ */ new Set(), contexts: /* @__PURE__ */ new Set() };
+      failuresByPair.set(key, rec);
+    }
+    rec.reasons.add(d.reason);
+    if (d.tagContext) rec.contexts.add(d.tagContext);
+  }
+  const prunedNodes = {};
+  const removed = [];
+  for (const [nodeId, list] of Object.entries(fb.nodes)) {
+    const contexts = (_a = nodeContexts.get(nodeId)) != null ? _a : [];
+    const totalContexts = Math.max(1, contexts.length);
+    const keep = [];
+    for (const cand of list) {
+      const key = `${nodeId}::${String(cand)}`;
+      const rec = failuresByPair.get(key);
+      if (!rec) {
+        keep.push(cand);
+        continue;
+      }
+      const failedContextsCount = rec.contexts.size > 0 ? rec.contexts.size : totalContexts;
+      const failsAll = failedContextsCount >= totalContexts;
+      if (failsAll) {
+        removed.push({
+          nodeId,
+          candidate: cand,
+          reasons: Array.from(rec.reasons),
+          contexts: contexts.length ? contexts.slice() : void 0
+        });
+      } else {
+        keep.push(cand);
+      }
+    }
+    if (keep.length) prunedNodes[nodeId] = keep;
+  }
+  const outProps = {
+    ...props,
+    fallbacks: {
+      ...((_b = props.fallbacks) == null ? void 0 : _b.global) ? { global: props.fallbacks.global } : {},
+      ...Object.keys(prunedNodes).length ? { nodes: prunedNodes } : {}
+    }
+  };
+  return { props: outProps, removed };
+}
+function toBindArray(bind) {
+  if (!bind) return [];
+  return Array.isArray(bind) ? bind.slice() : [bind];
+}
+
+// src/utils/util.ts
+function toFiniteNumber(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : NaN;
+}
+function constraintFitOk(svcMap, candidate, constraints) {
+  const cap = svcMap[Number(candidate)];
+  if (!cap) return false;
+  if (constraints.dripfeed === true && !cap.dripfeed) return false;
+  if (constraints.refill === true && !cap.refill) return false;
+  return !(constraints.cancel === true && !cap.cancel);
+}
+function rateOk(svcMap, candidate, primary, policy) {
+  var _a, _b, _c;
+  const cand = svcMap[Number(candidate)];
+  const prim = svcMap[Number(primary)];
+  if (!cand || !prim) return false;
+  const cRate = toFiniteNumber(cand.rate);
+  const pRate = toFiniteNumber(prim.rate);
+  if (!Number.isFinite(cRate) || !Number.isFinite(pRate)) return false;
+  const rp = (_a = policy.ratePolicy) != null ? _a : { kind: "lte_primary" };
+  switch (rp.kind) {
+    case "lte_primary":
+      return cRate <= pRate;
+    case "within_pct": {
+      const pct = Math.max(0, (_b = rp.pct) != null ? _b : 0);
+      return cRate <= pRate * (1 + pct / 100);
+    }
+    case "at_least_pct_lower": {
+      const pct = Math.max(0, (_c = rp.pct) != null ? _c : 0);
+      return cRate <= pRate * (1 - pct / 100);
+    }
+    default:
+      return false;
+  }
+}
+
+// src/utils/build-order-snapshot.ts
+function buildOrderSnapshot(props, builder, selection, services, settings = {}) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const mode = (_a = settings.mode) != null ? _a : "prod";
+  const hostDefaultQty = Number.isFinite(
+    (_b = settings.hostDefaultQuantity) != null ? _b : 1
+  ) ? settings.hostDefaultQuantity : 1;
+  const fbSettings = {
+    requireConstraintFit: true,
+    ratePolicy: { kind: "lte_primary" },
+    selectionStrategy: "priority",
+    mode: mode === "dev" ? "dev" : "strict",
+    ...(_c = settings.fallback) != null ? _c : {}
+  };
+  const builtAt = (/* @__PURE__ */ new Date()).toISOString();
+  const tagId = selection.activeTagId;
+  const selectedOptionKeys = toSelectedOptionKeys(
+    selection.optionSelectionsByFieldId
+  );
+  const visibleFieldIds = builder.visibleFields(
+    tagId,
+    selectedOptionKeys
+  );
+  const tagById = new Map(
+    ((_d = props.filters) != null ? _d : []).map((t) => [t.id, t])
+  );
+  const fieldById = new Map(
+    ((_e = props.fields) != null ? _e : []).map((f) => [f.id, f])
+  );
+  const tagConstraints = (_g = (_f = tagById.get(tagId)) == null ? void 0 : _f.constraints) != null ? _g : void 0;
+  const selectionFields = visibleFieldIds.map((fid) => fieldById.get(fid)).filter((f) => !!f).map((f) => {
+    var _a2;
+    const optIds = isOptionBased(f) ? (_a2 = selection.optionSelectionsByFieldId[f.id]) != null ? _a2 : [] : void 0;
+    return {
+      id: f.id,
+      type: String(f.type),
+      ...optIds && optIds.length ? { selectedOptions: optIds } : {}
+    };
+  });
+  const { formValues, selections } = buildInputs(
+    visibleFieldIds,
+    fieldById,
+    selection
+  );
+  const qtyRes = resolveQuantity(
+    visibleFieldIds,
+    fieldById,
+    selection,
+    hostDefaultQty
+  );
+  const quantity = qtyRes.quantity;
+  const quantitySource = qtyRes.source;
+  const { serviceMap, servicesList } = resolveServices(
+    tagId,
+    visibleFieldIds,
+    selection,
+    tagById,
+    fieldById
+  );
+  const { min, max } = resolveMinMax(servicesList, services);
+  const prunedFallbacks = pruneFallbacksConservative(
+    props.fallbacks,
+    { tagId, constraints: tagConstraints, serviceMap, servicesList },
+    services,
+    fbSettings
+  );
+  const utilities = collectUtilityLineItems(
+    visibleFieldIds,
+    fieldById,
+    selection,
+    quantity
+  );
+  const warnings = mode === "dev" ? buildDevWarnings(
+    props,
+    services,
+    tagId,
+    serviceMap,
+    prunedFallbacks.original,
+    prunedFallbacks.pruned,
+    fieldById,
+    visibleFieldIds,
+    selection
+  ) : void 0;
+  const snapshotPolicy = toSnapshotPolicy(fbSettings);
+  const meta = {
+    schema_version: props.schema_version,
+    workspaceId: settings.workspaceId,
+    builder: settings.builderCommit ? { commit: settings.builderCommit } : void 0,
+    context: {
+      tag: tagId,
+      constraints: tagConstraints != null ? tagConstraints : {},
+      nodeContexts: buildNodeContexts(
+        tagId,
+        visibleFieldIds,
+        fieldById,
+        selection
+      ),
+      policy: snapshotPolicy
+    }
+  };
+  const snapshot = {
+    version: "1",
+    mode,
+    builtAt,
+    selection: {
+      tag: tagId,
+      fields: selectionFields
+    },
+    inputs: {
+      form: formValues,
+      selections
+    },
+    min,
+    max: max != null ? max : min,
+    quantity,
+    quantitySource,
+    services: servicesList,
+    serviceMap,
+    ...prunedFallbacks.pruned ? { fallbacks: prunedFallbacks.pruned } : {},
+    ...utilities.length ? { utilities } : {},
+    ...warnings ? { warnings } : {},
+    meta
+  };
+  return snapshot;
+}
+function isOptionBased(f) {
+  const hasOptions = Array.isArray(f.options) && f.options.length > 0;
+  return hasOptions || isMultiField(f);
+}
+function toSelectedOptionKeys(byField) {
+  const keys = [];
+  for (const [fieldId, optionIds] of Object.entries(byField != null ? byField : {})) {
+    for (const optId of optionIds != null ? optionIds : []) {
+      keys.push(`${fieldId}::${optId}`);
+    }
+  }
+  return keys;
+}
+function buildInputs(visibleFieldIds, fieldById, selection) {
+  const formValues = {};
+  const selections = {};
+  for (const fid of visibleFieldIds) {
+    const f = fieldById.get(fid);
+    if (!f) continue;
+    const selOptIds = selection.optionSelectionsByFieldId[fid];
+    if (selOptIds && selOptIds.length) {
+      selections[fid] = [...selOptIds];
+    }
+    if (!isOptionBased(f)) {
+      const name = f.name;
+      const val = selection.formValuesByFieldId[fid];
+      if (!name || val === void 0) continue;
+      formValues[name] = val;
+    }
+  }
+  return { formValues, selections };
+}
+function resolveQuantity(visibleFieldIds, fieldById, selection, hostDefault) {
+  var _a;
+  for (const fid of visibleFieldIds) {
+    const f = fieldById.get(fid);
+    if (!f) continue;
+    const rule = readQuantityRule(
+      (_a = f.meta) == null ? void 0 : _a.quantity
+    );
+    if (!rule) continue;
+    const raw = selection.formValuesByFieldId[fid];
+    const evaluated = evaluateQuantityRule(rule, raw);
+    if (Number.isFinite(evaluated) && evaluated > 0) {
+      return {
+        quantity: evaluated,
+        source: { kind: "field", id: f.id, rule }
+      };
+    }
+  }
+  return {
+    quantity: hostDefault,
+    source: { kind: "default", defaultedFromHost: true }
+  };
+}
+function readQuantityRule(v) {
+  if (!v || typeof v !== "object") return void 0;
+  const src = v;
+  if (src.valueBy !== "value" && src.valueBy !== "length" && src.valueBy !== "eval")
+    return void 0;
+  const out = { valueBy: src.valueBy };
+  if (src.code && typeof src.code === "string") out.code = src.code;
+  return out;
+}
+function evaluateQuantityRule(rule, raw) {
+  switch (rule.valueBy) {
+    case "value": {
+      const n = Number(Array.isArray(raw) ? raw[0] : raw);
+      return Number.isFinite(n) ? n : NaN;
+    }
+    case "length": {
+      if (Array.isArray(raw)) return raw.length;
+      if (typeof raw === "string") return raw.length;
+      return NaN;
+    }
+    case "eval": {
+      try {
+        if (!rule.code || typeof rule.code !== "string") return NaN;
+        const fn = new Function(
+          "value",
+          "values",
+          `return (function(){ ${rule.code}
+})()`
+        );
+        const single = Array.isArray(raw) ? raw[0] : raw;
+        const values = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+        const out = fn(single, values);
+        const n = Number(out);
+        return Number.isFinite(n) ? n : NaN;
+      } catch {
+        return NaN;
+      }
+    }
+    default:
+      return NaN;
+  }
+}
+function resolveServices(tagId, visibleFieldIds, selection, tagById, fieldById) {
+  var _a;
+  const serviceMap = {};
+  const ordered = [];
+  const tag = tagById.get(tagId);
+  let primary;
+  let primaryOrigin;
+  if ((tag == null ? void 0 : tag.service_id) !== void 0) {
+    primary = tag.service_id;
+    primaryOrigin = "tag";
+  }
+  const optionVisit = buildOptionVisitOrder(selection, fieldById);
+  for (const { fieldId, optionId } of optionVisit) {
+    if (!visibleFieldIds.includes(fieldId)) continue;
+    const f = fieldById.get(fieldId);
+    if (!f || !Array.isArray(f.options)) continue;
+    const opt = f.options.find((o) => o.id === optionId);
+    if (!opt) continue;
+    const role = (_a = opt.pricing_role) != null ? _a : "base";
+    const sid = opt.service_id;
+    if (role === "utility") continue;
+    if (sid !== void 0) {
+      if (primary === void 0 || primaryOrigin === "tag") {
+        primary = sid;
+        primaryOrigin = "option";
+        ordered.length = 0;
+        ordered.push(primary);
+      } else {
+        ordered.push(sid);
+      }
+      pushService(serviceMap, optionId, sid);
+    }
+  }
+  if (primaryOrigin !== "option" && primary !== void 0) {
+    ordered.unshift(primary);
+    pushService(serviceMap, tagId, primary);
+  } else {
+  }
+  const servicesList = dedupeByString(ordered);
+  return { serviceMap, servicesList };
+}
+function buildOptionVisitOrder(selection, fieldById) {
+  var _a;
+  if (selection.optionTraversalOrder && selection.optionTraversalOrder.length) {
+    return selection.optionTraversalOrder.slice();
+  }
+  const out = [];
+  for (const [fid, optIds] of Object.entries(
+    (_a = selection.optionSelectionsByFieldId) != null ? _a : {}
+  )) {
+    const f = fieldById.get(fid);
+    if (!f) continue;
+    for (const oid of optIds != null ? optIds : [])
+      out.push({ fieldId: fid, optionId: oid });
+  }
+  return out;
+}
+function pushService(map, nodeId, sid) {
+  if (!map[nodeId]) map[nodeId] = [];
+  map[nodeId].push(sid);
+}
+function dedupeByString(arr) {
+  const s = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const v of arr) {
+    const key = String(v);
+    if (s.has(key)) continue;
+    s.add(key);
+    out.push(v);
+  }
+  return out;
+}
+function pruneFallbacksConservative(fallbacks, env, svcMap, policy) {
+  var _a, _b;
+  if (!fallbacks) return { pruned: void 0, original: void 0 };
+  try {
+    const { props: prunedProps } = pruneInvalidNodeFallbacks(
+      {
+        filters: [],
+        fields: [],
+        schema_version: "1.0",
+        fallbacks
+      },
+      svcMap,
+      policy
+    );
+    return {
+      pruned: prunedProps.fallbacks,
+      original: fallbacks
+    };
+  } catch {
+    const out = {};
+    const requireFit = (_a = policy.requireConstraintFit) != null ? _a : true;
+    if (fallbacks.nodes) {
+      const keptNodes = {};
+      for (const [nodeId, candidates] of Object.entries(
+        fallbacks.nodes
+      )) {
+        if (!env.serviceMap[nodeId]) continue;
+        const primary = ((_b = env.serviceMap[nodeId]) != null ? _b : [])[0];
+        const kept = [];
+        for (const cand of candidates != null ? candidates : []) {
+          if (!rateOk(svcMap, cand, primary, policy)) continue;
+          if (requireFit && env.constraints && !constraintFitOk(svcMap, cand, env.constraints))
+            continue;
+          kept.push(cand);
+        }
+        if (kept.length) keptNodes[nodeId] = kept;
+      }
+      if (Object.keys(keptNodes).length) out.nodes = keptNodes;
+    }
+    if (fallbacks.global) {
+      const keptGlobal = {};
+      const present = new Set(env.servicesList.map((sid) => String(sid)));
+      for (const [primary, cands] of Object.entries(
+        fallbacks.global
+      )) {
+        if (!present.has(String(primary))) continue;
+        const primId = isFiniteNumber3(primary) ? Number(primary) : primary;
+        const kept = [];
+        for (const cand of cands != null ? cands : []) {
+          if (!rateOk(svcMap, cand, primId, policy)) continue;
+          if (requireFit && env.constraints && !constraintFitOk(svcMap, cand, env.constraints))
+            continue;
+          kept.push(cand);
+        }
+        if (kept.length) keptGlobal[primId] = kept;
+      }
+      if (Object.keys(keptGlobal).length)
+        out.global = keptGlobal;
+    }
+    return {
+      pruned: Object.keys(out).length ? out : void 0,
+      original: fallbacks
+    };
+  }
+}
+function isFiniteNumber3(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function collectUtilityLineItems(visibleFieldIds, fieldById, selection, quantity) {
+  var _a, _b, _c, _d, _e;
+  const items = [];
+  for (const fid of visibleFieldIds) {
+    const f = fieldById.get(fid);
+    if (!f) continue;
+    const isUtilityField = ((_a = f.pricing_role) != null ? _a : "base") === "utility";
+    const marker = readUtilityMarker((_b = f.meta) == null ? void 0 : _b.utility);
+    if (isUtilityField && marker) {
+      const val = selection.formValuesByFieldId[f.id];
+      const item = buildUtilityItemFromMarker(
+        f.id,
+        marker,
+        quantity,
+        val
+      );
+      if (item) items.push(item);
+    }
+    if (Array.isArray(f.options) && f.options.length) {
+      const selectedOptIds = (_c = selection.optionSelectionsByFieldId[f.id]) != null ? _c : [];
+      if (selectedOptIds.length) {
+        const optById = new Map(
+          f.options.map((o) => [o.id, o])
+        );
+        for (const oid of selectedOptIds) {
+          const opt = optById.get(oid);
+          if (!opt) continue;
+          if (((_d = opt.pricing_role) != null ? _d : "base") !== "utility") continue;
+          const om = readUtilityMarker((_e = opt.meta) == null ? void 0 : _e.utility);
+          if (!om) continue;
+          const parentVal = selection.formValuesByFieldId[f.id];
+          const item = buildUtilityItemFromMarker(
+            opt.id,
+            om,
+            quantity,
+            parentVal
+          );
+          if (item) items.push(item);
+        }
+      }
+    }
+  }
+  return items;
+}
+function readUtilityMarker(v) {
+  if (!v || typeof v !== "object") return void 0;
+  const src = v;
+  if (!src.mode || typeof src.rate !== "number" || !Number.isFinite(src.rate))
+    return void 0;
+  if (src.mode !== "flat" && src.mode !== "per_quantity" && src.mode !== "per_value" && src.mode !== "percent")
+    return void 0;
+  const out = { mode: src.mode, rate: src.rate };
+  if (src.valueBy === "value" || src.valueBy === "length" || src.valueBy === "eval")
+    out.valueBy = src.valueBy;
+  if (src.code && typeof src.code === "string") out.code = src.code;
+  return out;
+}
+function buildUtilityItemFromMarker(nodeId, marker, quantity, value) {
+  var _a, _b;
+  const base = {
+    nodeId,
+    mode: marker.mode,
+    rate: marker.rate,
+    inputs: { quantity }
+  };
+  if (marker.mode === "per_value") {
+    base.inputs.valueBy = (_a = marker.valueBy) != null ? _a : "value";
+    if (marker.valueBy === "length") {
+      base.inputs.value = Array.isArray(value) ? value.length : typeof value === "string" ? value.length : 0;
+    } else if (marker.valueBy === "eval") {
+      base.inputs.evalCodeUsed = true;
+    } else {
+      base.inputs.value = Array.isArray(value) ? (_b = value[0]) != null ? _b : null : value != null ? value : null;
+    }
+  }
+  return base;
+}
+function buildNodeContexts(tagId, visibleFieldIds, fieldById, selection) {
+  var _a;
+  const ctx = {};
+  ctx[tagId] = tagId;
+  for (const fid of visibleFieldIds) {
+    const f = fieldById.get(fid);
+    if (!f) continue;
+    const binds = normalizeBindIds(f.bind_id);
+    const applicable = binds.has(tagId);
+    const selectedOptIds = (_a = selection.optionSelectionsByFieldId[fid]) != null ? _a : [];
+    for (const oid of selectedOptIds) {
+      ctx[oid] = applicable ? tagId : null;
+    }
+  }
+  return ctx;
+}
+function normalizeBindIds(bind) {
+  const out = /* @__PURE__ */ new Set();
+  if (!bind) return out;
+  if (Array.isArray(bind)) {
+    for (const b of bind) if (b) out.add(String(b));
+  } else {
+    out.add(String(bind));
+  }
+  return out;
+}
+function buildDevWarnings(props, svcMap, _tagId, _snapshotServiceMap, originalFallbacks, _prunedFallbacks, fieldById, visibleFieldIds, selection) {
+  const out = {};
+  const maybeCollectFailed = globalThis.collectFailedFallbacks;
+  try {
+    if (maybeCollectFailed && originalFallbacks) {
+      const diags = maybeCollectFailed(
+        {
+          ...props,
+          fallbacks: originalFallbacks
+        },
+        svcMap,
+        { mode: "dev" }
+      );
+      if (diags && diags.length) {
+        out.fallbacks = diags;
+      }
+    }
+  } catch {
+  }
+  const utilityWarnings = [];
+  for (const fid of visibleFieldIds) {
+    const f = fieldById.get(fid);
+    if (!f) continue;
+    const hasVal = selection.formValuesByFieldId[fid] !== void 0;
+    if (hasVal && !f.name && !isOptionBased(f)) {
+      utilityWarnings.push({
+        nodeId: fid,
+        reason: "missing_field_name_for_form_value"
+      });
+    }
+  }
+  if (utilityWarnings.length) {
+    out.utility = utilityWarnings;
+  }
+  if (!out.fallbacks && !out.utility) return void 0;
+  return out;
+}
+function toSnapshotPolicy(settings) {
+  var _a, _b, _c;
+  const requireConstraintFit = (_a = settings.requireConstraintFit) != null ? _a : true;
+  const rp = (_b = settings.ratePolicy) != null ? _b : { kind: "lte_primary" };
+  switch (rp.kind) {
+    case "lte_primary":
+      return {
+        ratePolicy: { kind: "lte_primary" },
+        requireConstraintFit
+      };
+    case "within_pct":
+      return {
+        ratePolicy: {
+          kind: "lte_primary",
+          thresholdPct: Math.max(0, (_c = rp.pct) != null ? _c : 0)
+        },
+        requireConstraintFit
+      };
+    case "at_least_pct_lower":
+      return {
+        ratePolicy: { kind: "lte_primary" },
+        requireConstraintFit
+      };
+    default:
+      return {
+        ratePolicy: { kind: "lte_primary" },
+        requireConstraintFit
+      };
+  }
+}
+function getCap2(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 resolveMinMax(servicesList, services) {
+  let min = void 0;
+  let max = void 0;
+  for (const sid of servicesList) {
+    const cap = getCap2(services, sid);
+    if (!cap) continue;
+    if (typeof cap.min === "number" && Number.isFinite(cap.min)) {
+      min = min === void 0 ? cap.min : Math.min(min, cap.min);
+    }
+    if (typeof cap.max === "number" && Number.isFinite(cap.max)) {
+      max = max === void 0 ? cap.max : Math.max(max, cap.max);
+    }
+  }
+  return { min: min != null ? min : 1, ...max !== void 0 ? { max } : {} };
+}
 export {
+  buildOrderSnapshot,
   collectFailedFallbacks,
   createBuilder,
   createNodeIndex,
@@ -2894,6 +3795,7 @@ export {
   normalise,
   resolveServiceFallback,
   validate,
+  validateAsync,
   validateRateCoherenceDeep
 };
 //# sourceMappingURL=index.js.map