@timeax/digital-service-engine 0.0.1

package/dist/react/index.cjs

@@ -0,0 +1,4015 @@
+"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/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  CanvasAPI: () => CanvasAPI,
+  EventBus: () => EventBus,
+  FormProvider: () => FormProvider,
+  Provider: () => Provider,
+  Wrapper: () => Wrapper,
+  createInputRegistry: () => createInputRegistry,
+  resolveInputDescriptor: () => resolveInputDescriptor,
+  useFormApi: () => useFormApi,
+  useFormField: () => useFormField,
+  useFormSelections: () => useFormSelections,
+  useInputs: () => useInputs,
+  useOptionalFormApi: () => useOptionalFormApi
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/canvas/events.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    var _a;
+    const set = (_a = this.listeners.get(event)) != null ? _a : /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.listeners.set(event, set);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  once(event, handler) {
+    const off = this.on(event, (p) => {
+      off();
+      handler(p);
+    });
+    return off;
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set || set.size === 0) return;
+    for (const h of Array.from(set)) try {
+      h(payload);
+    } catch {
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/utils/retry-queue.ts
+var RetryQueue = class {
+  constructor(opts = {}) {
+    this.jobs = /* @__PURE__ */ new Map();
+    this.paused = false;
+    var _a, _b, _c, _d, _e, _f;
+    this.opts = {
+      enabled: (_a = opts.enabled) != null ? _a : true,
+      maxAttempts: (_b = opts.maxAttempts) != null ? _b : 5,
+      baseDelayMs: (_c = opts.baseDelayMs) != null ? _c : 800,
+      maxDelayMs: (_d = opts.maxDelayMs) != null ? _d : 2e4,
+      jitter: (_e = opts.jitter) != null ? _e : true,
+      immediateFirst: (_f = opts.immediateFirst) != null ? _f : false
+    };
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+    this.flush();
+  }
+  /** Enqueue or no-op if a job with same id already exists */
+  enqueue(job) {
+    var _a;
+    if (!this.opts.enabled) return false;
+    if (this.jobs.has(job.id)) return false;
+    this.jobs.set(job.id, { job, attempt: 0 });
+    (_a = job.onStatus) == null ? void 0 : _a.call(job, "scheduled", { attempt: 0 });
+    this.kick(job.id);
+    return true;
+  }
+  /** Force retry now (resets backoff); returns false if not found */
+  triggerNow(id) {
+    const rec = this.jobs.get(id);
+    if (!rec) return false;
+    if (rec.timer) clearTimeout(rec.timer);
+    rec.timer = void 0;
+    this.kick(id, true);
+    return true;
+  }
+  cancel(id) {
+    var _a, _b;
+    const rec = this.jobs.get(id);
+    if (!rec) return false;
+    if (rec.timer) clearTimeout(rec.timer);
+    rec.cancelled = true;
+    (_b = (_a = rec.job).onStatus) == null ? void 0 : _b.call(_a, "cancelled", { attempt: rec.attempt });
+    this.jobs.delete(id);
+    return true;
+  }
+  pendingIds() {
+    return Array.from(this.jobs.keys());
+  }
+  size() {
+    return this.jobs.size;
+  }
+  isQueued(id) {
+    return this.jobs.has(id);
+  }
+  drain() {
+    var _a, _b;
+    for (const [id, rec] of this.jobs.entries()) {
+      if (rec.timer) clearTimeout(rec.timer);
+      rec.cancelled = true;
+      (_b = (_a = rec.job).onStatus) == null ? void 0 : _b.call(_a, "cancelled", { attempt: rec.attempt });
+      this.jobs.delete(id);
+    }
+  }
+  flush() {
+    for (const id of this.jobs.keys()) this.kick(id);
+  }
+  delayFor(attempt) {
+    const { baseDelayMs, maxDelayMs, jitter } = this.opts;
+    const exp = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, Math.max(0, attempt - 1)));
+    if (!jitter) return exp;
+    const r = Math.random() * 0.4 + 0.8;
+    return Math.min(maxDelayMs, Math.floor(exp * r));
+  }
+  async kick(id, immediate = false) {
+    var _a, _b;
+    const rec = this.jobs.get(id);
+    if (!rec || rec.cancelled) return;
+    if (this.paused && !immediate) return;
+    const attempt = rec.attempt + 1;
+    const run = async () => {
+      var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j;
+      if (rec.cancelled) return;
+      (_b2 = (_a2 = rec.job).onStatus) == null ? void 0 : _b2.call(_a2, "retrying", { attempt });
+      try {
+        const ok = await rec.job.perform(attempt);
+        if (ok) {
+          (_d = (_c = rec.job).onStatus) == null ? void 0 : _d.call(_c, "succeeded", { attempt });
+          this.jobs.delete(id);
+          return;
+        }
+      } catch (err) {
+        (_f = (_e = rec.job).onStatus) == null ? void 0 : _f.call(_e, "failed", { attempt, error: err });
+      }
+      if (attempt >= this.opts.maxAttempts) {
+        (_h = (_g = rec.job).onStatus) == null ? void 0 : _h.call(_g, "failed", { attempt });
+        this.jobs.delete(id);
+        return;
+      }
+      rec.attempt = attempt;
+      const delay = this.delayFor(attempt);
+      (_j = (_i = rec.job).onStatus) == null ? void 0 : _j.call(_i, "scheduled", { attempt, nextDelayMs: delay });
+      rec.timer = setTimeout(() => this.kick(id), delay);
+    };
+    if (immediate) await run();
+    else {
+      const delay = this.opts.immediateFirst && attempt === 1 ? 0 : this.delayFor(attempt);
+      if (delay) {
+        (_b = (_a = rec.job).onStatus) == null ? void 0 : _b.call(_a, "scheduled", { attempt: 0, nextDelayMs: delay });
+        rec.timer = setTimeout(run, delay);
+      } else {
+        void run();
+      }
+    }
+  }
+};
+
+// src/react/canvas/comments.ts
+var __seq = 0;
+var newLocalId = (p = "loc") => `${p}_${Date.now().toString(36)}_${(++__seq).toString(36)}`;
+var CommentsAPI = class {
+  constructor(bus, deps = {}) {
+    this.threads = /* @__PURE__ */ new Map();
+    this.bus = bus;
+    this.deps = deps;
+    this.retry = new RetryQueue(deps.retry);
+  }
+  scope() {
+    var _a, _b;
+    return (_b = (_a = this.deps).getScope) == null ? void 0 : _b.call(_a);
+  }
+  emitSync(op, threadId, messageId, status, meta) {
+    this.bus.emit("comment:sync", {
+      op,
+      threadId,
+      messageId,
+      status,
+      attempt: meta.attempt,
+      nextDelayMs: meta.nextDelayMs,
+      error: meta.error
+    });
+  }
+  /* ─── Persistence bridge ───────────────────────────── */
+  async loadAll() {
+    if (!this.deps.backend) return;
+    const scope = this.scope();
+    if (!scope) return;
+    const res = await this.deps.backend.listThreads(scope);
+    if (!res.ok) {
+      this.bus.emit("error", {
+        message: res.error.message,
+        code: res.error.code,
+        meta: res.error.meta
+      });
+      return;
+    }
+    this.threads.clear();
+    for (const th of res.value) {
+      this.threads.set(th.id, { ...th, _sync: "synced" });
+    }
+    this.bus.emit("comment:thread:update", { thread: void 0 });
+  }
+  /* ─── Query ─────────────────────────────────────────── */
+  list() {
+    return Array.from(this.threads.values()).sort((a, b) => a.createdAt - b.createdAt).map((t) => t);
+  }
+  get(id) {
+    return this.threads.get(id);
+  }
+  /* ─── Mutations (optimistic if backend present) ─────── */
+  async create(anchor, initialBody, meta) {
+    var _a, _b;
+    const now = Date.now();
+    const localId = newLocalId("t");
+    const msgId = newLocalId("m");
+    const hasBackend = Boolean(this.deps.backend && this.scope());
+    const local = {
+      id: localId,
+      anchor,
+      resolved: false,
+      createdAt: now,
+      updatedAt: now,
+      messages: [{ id: msgId, body: initialBody, createdAt: now }],
+      meta,
+      _sync: hasBackend ? "pending" : "synced"
+    };
+    this.threads.set(localId, local);
+    this.bus.emit("comment:thread:create", { thread: local });
+    if (!this.deps.backend) return localId;
+    const performOnce = async () => {
+      const scope = this.scope();
+      if (!scope) return localId;
+      const res = await this.deps.backend.createThread(scope, {
+        anchor,
+        body: initialBody,
+        meta
+      });
+      if (!res.ok) throw res.error;
+      this.threads.delete(localId);
+      const serverTh = {
+        ...res.value,
+        _sync: "synced"
+      };
+      this.threads.set(serverTh.id, serverTh);
+      this.bus.emit("comment:thread:update", { thread: serverTh });
+      return serverTh.id;
+    };
+    try {
+      const serverId = await performOnce();
+      return serverId;
+    } catch (err) {
+      const scope = this.scope();
+      const branchKey = (_a = scope == null ? void 0 : scope.branchId) != null ? _a : "no_branch";
+      const jobId = `comments:create_thread:${branchKey}:${localId}`;
+      this.retry.enqueue({
+        id: jobId,
+        perform: async () => {
+          try {
+            await performOnce();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        onStatus: (status, meta2) => this.emitSync(
+          "create_thread",
+          localId,
+          void 0,
+          status,
+          meta2 != null ? meta2 : { attempt: 0 }
+        )
+      });
+      local._sync = "error";
+      this.bus.emit("error", {
+        message: (_b = err == null ? void 0 : err.message) != null ? _b : "Create failed",
+        code: err == null ? void 0 : err.code,
+        meta: err
+      });
+      this.bus.emit("comment:thread:update", { thread: local });
+      return localId;
+    }
+  }
+  async reply(threadId, body, meta) {
+    var _a, _b, _c;
+    const th = this.ensure(threadId);
+    const now = Date.now();
+    const localMid = newLocalId("m");
+    const hasBackend = Boolean(this.deps.backend && this.scope());
+    const localMsg = {
+      id: localMid,
+      body,
+      createdAt: now,
+      meta
+    };
+    th.messages.push(localMsg);
+    th.updatedAt = now;
+    (_a = th._sync) != null ? _a : th._sync = hasBackend ? "pending" : "synced";
+    this.bus.emit("comment:message:create", {
+      threadId,
+      message: localMsg
+    });
+    this.bus.emit("comment:thread:update", { thread: th });
+    if (!this.deps.backend) return localMid;
+    const performOnce = async () => {
+      const scope = this.scope();
+      if (!scope) return localMid;
+      const res = await this.deps.backend.addMessage(scope, {
+        threadId: th.id,
+        body,
+        meta
+      });
+      if (!res.ok) throw res.error;
+      const serverMsg = res.value;
+      const idx = th.messages.findIndex((m) => m.id === localMid);
+      if (idx >= 0) th.messages[idx] = serverMsg;
+      th._sync = "synced";
+      this.bus.emit("comment:thread:update", { thread: th });
+      return serverMsg.id;
+    };
+    try {
+      const serverMid = await performOnce();
+      return serverMid;
+    } catch (err) {
+      const scope = this.scope();
+      const branchKey = (_b = scope == null ? void 0 : scope.branchId) != null ? _b : "no_branch";
+      const jobId = `comments:add_message:${branchKey}:${threadId}:${localMid}`;
+      this.retry.enqueue({
+        id: jobId,
+        perform: async () => {
+          try {
+            await performOnce();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        onStatus: (status, meta2) => this.emitSync(
+          "add_message",
+          threadId,
+          localMid,
+          status,
+          meta2 != null ? meta2 : { attempt: 0 }
+        )
+      });
+      th._sync = "error";
+      this.bus.emit("error", {
+        message: (_c = err == null ? void 0 : err.message) != null ? _c : "Reply failed",
+        code: err == null ? void 0 : err.code,
+        meta: err
+      });
+      this.bus.emit("comment:thread:update", { thread: th });
+      return localMid;
+    }
+  }
+  async editMessage(threadId, messageId, body) {
+    var _a, _b, _c;
+    const th = this.ensure(threadId);
+    const orig = th.messages.find((m) => m.id === messageId);
+    if (!orig) return;
+    const previous = { ...orig };
+    orig.body = body;
+    orig.editedAt = Date.now();
+    th.updatedAt = orig.editedAt;
+    const hasBackend = Boolean(this.deps.backend && this.scope());
+    (_a = th._sync) != null ? _a : th._sync = hasBackend ? "pending" : "synced";
+    this.bus.emit("comment:thread:update", { thread: th });
+    if (!this.deps.backend) return;
+    const performOnce = async () => {
+      const scope = this.scope();
+      if (!scope) return;
+      const res = await this.deps.backend.editMessage(scope, {
+        threadId: th.id,
+        messageId,
+        body
+      });
+      if (!res.ok) throw res.error;
+      const idx = th.messages.findIndex((m) => m.id === messageId);
+      if (idx >= 0) th.messages[idx] = res.value;
+      th._sync = "synced";
+      this.bus.emit("comment:thread:update", { thread: th });
+    };
+    try {
+      await performOnce();
+    } catch (err) {
+      const scope = this.scope();
+      const branchKey = (_b = scope == null ? void 0 : scope.branchId) != null ? _b : "no_branch";
+      const jobId = `comments:edit_message:${branchKey}:${threadId}:${messageId}`;
+      this.retry.enqueue({
+        id: jobId,
+        perform: async () => {
+          try {
+            await performOnce();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        onStatus: (status, meta2) => this.emitSync(
+          "edit_message",
+          threadId,
+          messageId,
+          status,
+          meta2 != null ? meta2 : { attempt: 0 }
+        )
+      });
+      const idx = th.messages.findIndex((m) => m.id === messageId);
+      if (idx >= 0) th.messages[idx] = previous;
+      th._sync = "error";
+      this.bus.emit("error", {
+        message: (_c = err == null ? void 0 : err.message) != null ? _c : "Edit failed",
+        code: err == null ? void 0 : err.code,
+        meta: err
+      });
+      this.bus.emit("comment:thread:update", { thread: th });
+    }
+  }
+  async deleteMessage(threadId, messageId) {
+    var _a, _b, _c;
+    const th = this.ensure(threadId);
+    const backup = [...th.messages];
+    th.messages = th.messages.filter((m) => m.id !== messageId);
+    th.updatedAt = Date.now();
+    const hasBackend = Boolean(this.deps.backend && this.scope());
+    (_a = th._sync) != null ? _a : th._sync = hasBackend ? "pending" : "synced";
+    this.bus.emit("comment:thread:update", { thread: th });
+    if (!this.deps.backend) return;
+    const performOnce = async () => {
+      const scope = this.scope();
+      if (!scope) return;
+      const res = await this.deps.backend.deleteMessage(scope, {
+        threadId: th.id,
+        messageId
+      });
+      if (!res.ok) throw res.error;
+      th._sync = "synced";
+      this.bus.emit("comment:thread:update", { thread: th });
+    };
+    try {
+      await performOnce();
+    } catch (err) {
+      const scope = this.scope();
+      const branchKey = (_b = scope == null ? void 0 : scope.branchId) != null ? _b : "no_branch";
+      const jobId = `comments:delete_message:${branchKey}:${threadId}:${messageId}`;
+      this.retry.enqueue({
+        id: jobId,
+        perform: async () => {
+          try {
+            await performOnce();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        onStatus: (status, meta2) => this.emitSync(
+          "delete_message",
+          threadId,
+          messageId,
+          status,
+          meta2 != null ? meta2 : { attempt: 0 }
+        )
+      });
+      th.messages = backup;
+      th._sync = "error";
+      this.bus.emit("error", {
+        message: (_c = err == null ? void 0 : err.message) != null ? _c : "Delete failed",
+        code: err == null ? void 0 : err.code,
+        meta: err
+      });
+      this.bus.emit("comment:thread:update", { thread: th });
+    }
+  }
+  async move(threadId, anchor) {
+    var _a, _b, _c;
+    const th = this.ensure(threadId);
+    const prev = th.anchor;
+    th.anchor = anchor;
+    th.updatedAt = Date.now();
+    const hasBackend = Boolean(this.deps.backend && this.scope());
+    (_a = th._sync) != null ? _a : th._sync = hasBackend ? "pending" : "synced";
+    this.bus.emit("comment:move", { thread: th });
+    this.bus.emit("comment:thread:update", { thread: th });
+    if (!this.deps.backend) return;
+    const performOnce = async () => {
+      const scope = this.scope();
+      if (!scope) return;
+      const res = await this.deps.backend.moveThread(scope, {
+        threadId: th.id,
+        anchor
+      });
+      if (!res.ok) throw res.error;
+      this.threads.set(th.id, { ...res.value, _sync: "synced" });
+      this.bus.emit("comment:thread:update", {
+        thread: this.threads.get(threadId)
+      });
+    };
+    try {
+      await performOnce();
+    } catch (err) {
+      const scope = this.scope();
+      const branchKey = (_b = scope == null ? void 0 : scope.branchId) != null ? _b : "no_branch";
+      const jobId = `comments:move_thread:${branchKey}:${threadId}`;
+      this.retry.enqueue({
+        id: jobId,
+        perform: async () => {
+          try {
+            await performOnce();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        onStatus: (status, meta2) => this.emitSync(
+          "move_thread",
+          threadId,
+          void 0,
+          status,
+          meta2 != null ? meta2 : { attempt: 0 }
+        )
+      });
+      th.anchor = prev;
+      th._sync = "error";
+      this.bus.emit("error", {
+        message: (_c = err == null ? void 0 : err.message) != null ? _c : "Move failed",
+        code: err == null ? void 0 : err.code,
+        meta: err
+      });
+      this.bus.emit("comment:thread:update", { thread: th });
+    }
+  }
+  async resolve(threadId, value = true) {
+    var _a, _b, _c;
+    const th = this.ensure(threadId);
+    const prev = th.resolved;
+    th.resolved = value;
+    th.updatedAt = Date.now();
+    const hasBackend = Boolean(this.deps.backend && this.scope());
+    (_a = th._sync) != null ? _a : th._sync = hasBackend ? "pending" : "synced";
+    this.bus.emit("comment:resolve", { thread: th, resolved: value });
+    this.bus.emit("comment:thread:update", { thread: th });
+    if (!this.deps.backend) return;
+    const performOnce = async () => {
+      const scope = this.scope();
+      if (!scope) return;
+      const res = await this.deps.backend.resolveThread(scope, {
+        threadId: th.id,
+        resolved: value
+      });
+      if (!res.ok) throw res.error;
+      this.threads.set(th.id, { ...res.value, _sync: "synced" });
+      this.bus.emit("comment:thread:update", {
+        thread: this.threads.get(threadId)
+      });
+    };
+    try {
+      await performOnce();
+    } catch (err) {
+      const scope = this.scope();
+      const branchKey = (_b = scope == null ? void 0 : scope.branchId) != null ? _b : "no_branch";
+      const jobId = `comments:resolve_thread:${branchKey}:${threadId}`;
+      this.retry.enqueue({
+        id: jobId,
+        perform: async () => {
+          try {
+            await performOnce();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        onStatus: (status, meta2) => this.emitSync(
+          "resolve_thread",
+          threadId,
+          void 0,
+          status,
+          meta2 != null ? meta2 : { attempt: 0 }
+        )
+      });
+      th.resolved = prev;
+      th._sync = "error";
+      this.bus.emit("error", {
+        message: (_c = err == null ? void 0 : err.message) != null ? _c : "Resolve failed",
+        code: err == null ? void 0 : err.code,
+        meta: err
+      });
+      this.bus.emit("comment:thread:update", { thread: th });
+    }
+  }
+  async deleteThread(threadId) {
+    var _a, _b;
+    const prev = this.threads.get(threadId);
+    if (!prev) return;
+    this.threads.delete(threadId);
+    this.bus.emit("comment:thread:delete", { threadId });
+    if (!this.deps.backend) return;
+    const performOnce = async () => {
+      const scope = this.scope();
+      if (!scope) return;
+      const res = await this.deps.backend.deleteThread(scope, { threadId });
+      if (!res.ok) throw res.error;
+    };
+    try {
+      await performOnce();
+    } catch (err) {
+      const scope = this.scope();
+      const branchKey = (_a = scope == null ? void 0 : scope.branchId) != null ? _a : "no_branch";
+      const jobId = `comments:delete_thread:${branchKey}:${threadId}`;
+      this.retry.enqueue({
+        id: jobId,
+        perform: async () => {
+          try {
+            await performOnce();
+            return true;
+          } catch {
+            return false;
+          }
+        },
+        onStatus: (status, meta2) => this.emitSync(
+          "delete_thread",
+          threadId,
+          void 0,
+          status,
+          meta2 != null ? meta2 : { attempt: 0 }
+        )
+      });
+      this.threads.set(threadId, prev);
+      this.bus.emit("error", {
+        message: (_b = err == null ? void 0 : err.message) != null ? _b : "Delete thread failed",
+        code: err == null ? void 0 : err.code,
+        meta: err
+      });
+      this.bus.emit("comment:thread:update", { thread: prev });
+    }
+  }
+  // Optional helpers for UI controls
+  retryJob(jobId) {
+    return this.retry.triggerNow(jobId);
+  }
+  cancelJob(jobId) {
+    return this.retry.cancel(jobId);
+  }
+  pendingJobs() {
+    return this.retry.pendingIds();
+  }
+  /* ─── internal ────────────────────────────────────────── */
+  ensure(threadId) {
+    const th = this.threads.get(threadId);
+    if (!th) throw new Error(`Comment thread not found: ${threadId}`);
+    return th;
+  }
+};
+
+// src/react/canvas/editor.ts
+var import_lodash_es2 = require("lodash-es");
+
+// 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/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/policy.ts
+var ALLOWED_SCOPES = /* @__PURE__ */ new Set([
+  "global",
+  "visible_group"
+]);
+var ALLOWED_SUBJECTS = /* @__PURE__ */ new Set(["services"]);
+var ALLOWED_OPS = /* @__PURE__ */ new Set([
+  "all_equal",
+  "unique",
+  "no_mix",
+  "all_true",
+  "any_true",
+  "max_count",
+  "min_count"
+]);
+var ALLOWED_ROLES = /* @__PURE__ */ new Set([
+  "base",
+  "utility",
+  "both"
+]);
+var ALLOWED_SEVERITIES = /* @__PURE__ */ new Set([
+  "error",
+  "warning"
+]);
+var ALLOWED_WHERE_OPS = /* @__PURE__ */ new Set(["eq", "neq", "in", "nin", "exists", "truthy", "falsy"]);
+function normaliseWhere(src, d, i, id) {
+  if (src === void 0) return void 0;
+  if (!Array.isArray(src)) {
+    d.push({
+      ruleIndex: i,
+      ruleId: id,
+      severity: "warning",
+      message: "filter.where must be an array; ignored.",
+      path: "filter.where"
+    });
+    return void 0;
+  }
+  const out = [];
+  src.forEach((raw, j) => {
+    const obj = raw && typeof raw === "object" ? raw : null;
+    const path = typeof (obj == null ? void 0 : obj.path) === "string" && obj.path.trim() ? obj.path.trim() : void 0;
+    if (!path) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: `filter.where[${j}].path must be a non-empty string; entry ignored.`,
+        path: `filter.where[${j}].path`
+      });
+      return;
+    }
+    if (!path.startsWith("service.")) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: `filter.where[${j}].path should start with "service." for subject "services".`,
+        path: `filter.where[${j}].path`
+      });
+    }
+    const opRaw = obj == null ? void 0 : obj.op;
+    const op = opRaw === void 0 ? "eq" : typeof opRaw === "string" && ALLOWED_WHERE_OPS.has(opRaw) ? opRaw : "eq";
+    if (opRaw !== void 0 && !(typeof opRaw === "string" && ALLOWED_WHERE_OPS.has(opRaw))) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: `Unknown filter.where[${j}].op; defaulted to "eq".`,
+        path: `filter.where[${j}].op`
+      });
+    }
+    const value = obj == null ? void 0 : obj.value;
+    if (op === "exists" || op === "truthy" || op === "falsy") {
+      if (value !== void 0) {
+        d.push({
+          ruleIndex: i,
+          ruleId: id,
+          severity: "warning",
+          message: `filter.where[${j}] op "${op}" does not use "value".`,
+          path: `filter.where[${j}].value`
+        });
+      }
+    } else if (op === "in" || op === "nin") {
+      if (!Array.isArray(value)) {
+        d.push({
+          ruleIndex: i,
+          ruleId: id,
+          severity: "warning",
+          message: `filter.where[${j}] op "${op}" expects an array "value".`,
+          path: `filter.where[${j}].value`
+        });
+      }
+    }
+    out.push({ path, op, value });
+  });
+  return out.length ? out : void 0;
+}
+function compilePolicies(raw) {
+  const diagnostics = [];
+  const policies = [];
+  if (!Array.isArray(raw)) {
+    diagnostics.push({
+      ruleIndex: -1,
+      severity: "error",
+      message: "Policies root must be an array."
+    });
+    return { policies, diagnostics };
+  }
+  raw.forEach((entry, i) => {
+    const d = [];
+    const src = entry && typeof entry === "object" ? entry : {};
+    let id = typeof src.id === "string" && src.id.trim() ? src.id.trim() : void 0;
+    if (!id) {
+      id = `policy_${i + 1}`;
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: 'Missing "id"; generated automatically.',
+        path: "id"
+      });
+    }
+    const label = typeof src.label === "string" && src.label.trim() ? src.label.trim() : id;
+    if (!(typeof src.label === "string" && src.label.trim())) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: 'Missing "label"; defaulted to rule id.',
+        path: "label"
+      });
+    }
+    let scope = ALLOWED_SCOPES.has(src.scope) ? src.scope : src.scope === void 0 ? "visible_group" : "visible_group";
+    if (src.scope !== void 0 && !ALLOWED_SCOPES.has(src.scope)) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: 'Unknown "scope"; defaulted to "visible_group".',
+        path: "scope"
+      });
+    }
+    let subject = ALLOWED_SUBJECTS.has(src.subject) ? src.subject : "services";
+    if (src.subject !== void 0 && !ALLOWED_SUBJECTS.has(src.subject)) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: 'Unknown "subject"; defaulted to "services".',
+        path: "subject"
+      });
+    }
+    const op = src.op;
+    if (!ALLOWED_OPS.has(op)) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "error",
+        message: `Invalid "op": ${String(op)}.`,
+        path: "op"
+      });
+    }
+    let projection = typeof src.projection === "string" && src.projection.trim() ? src.projection.trim() : "service.id";
+    if (subject === "services" && projection && !projection.startsWith("service.")) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: 'Projection should start with "service." for subject "services".',
+        path: "projection"
+      });
+    }
+    const filterSrc = src.filter && typeof src.filter === "object" ? src.filter : void 0;
+    const role = (filterSrc == null ? void 0 : filterSrc.role) && ALLOWED_ROLES.has(filterSrc.role) ? filterSrc.role : "both";
+    if ((filterSrc == null ? void 0 : filterSrc.role) && !ALLOWED_ROLES.has(filterSrc.role)) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: 'Unknown filter.role; defaulted to "both".',
+        path: "filter.role"
+      });
+    }
+    const filter = {
+      role,
+      tag_id: (filterSrc == null ? void 0 : filterSrc.tag_id) !== void 0 ? Array.isArray(filterSrc.tag_id) ? filterSrc.tag_id : [filterSrc.tag_id] : void 0,
+      field_id: (filterSrc == null ? void 0 : filterSrc.field_id) !== void 0 ? Array.isArray(filterSrc.field_id) ? filterSrc.field_id : [filterSrc.field_id] : void 0,
+      where: normaliseWhere(filterSrc == null ? void 0 : filterSrc.where, d, i, id)
+    };
+    const severity = ALLOWED_SEVERITIES.has(src.severity) ? src.severity : "error";
+    if (src.severity !== void 0 && !ALLOWED_SEVERITIES.has(src.severity)) {
+      d.push({
+        ruleIndex: i,
+        ruleId: id,
+        severity: "warning",
+        message: 'Unknown "severity"; defaulted to "error".',
+        path: "severity"
+      });
+    }
+    const value = src.value;
+    if (op === "max_count" || op === "min_count") {
+      if (!(typeof value === "number" && Number.isFinite(value))) {
+        d.push({
+          ruleIndex: i,
+          ruleId: id,
+          severity: "error",
+          message: `"${op}" requires numeric "value".`,
+          path: "value"
+        });
+      }
+    } else if (op === "all_true" || op === "any_true") {
+      if (value !== void 0) {
+        d.push({
+          ruleIndex: i,
+          ruleId: id,
+          severity: "warning",
+          message: `"${op}" ignores "value"; it checks all/any true.`,
+          path: "value"
+        });
+      }
+    } else {
+      if (value !== void 0) {
+        d.push({
+          ruleIndex: i,
+          ruleId: id,
+          severity: "warning",
+          message: `"${op}" does not use "value".`,
+          path: "value"
+        });
+      }
+    }
+    const hasFatal = d.some((x) => x.severity === "error");
+    if (!hasFatal) {
+      const rule = {
+        id,
+        label,
+        // ✅ now always present
+        scope,
+        subject,
+        filter,
+        projection,
+        op,
+        value,
+        severity,
+        message: typeof src.message === "string" ? src.message : void 0
+      };
+      policies.push(rule);
+    }
+    diagnostics.push(...d);
+  });
+  return { policies, diagnostics };
+}
+
+// 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/react/canvas/editor.ts
+var MAX_LIMIT = 100;
+var isTagId = (id) => id.startsWith("t:");
+var isFieldId = (id) => id.startsWith("f:");
+var isOptionId = (id) => id.startsWith("o:");
+function ownerOfOption(props, optionId) {
+  var _a, _b;
+  for (const f of (_a = props.fields) != null ? _a : []) {
+    const idx = ((_b = f.options) != null ? _b : []).findIndex((o) => o.id === optionId);
+    if (idx >= 0) return { fieldId: f.id, index: idx };
+  }
+  return null;
+}
+function ensureServiceExists(opts, id) {
+  if (typeof opts.serviceExists === "function") {
+    if (!opts.serviceExists(id))
+      throw new Error(`service_not_found:${String(id)}`);
+    return;
+  }
+  if (opts.serviceMap) {
+    if (!Object.prototype.hasOwnProperty.call(opts.serviceMap, id)) {
+      throw new Error(`service_not_found:${String(id)}`);
+    }
+    return;
+  }
+  throw new Error("service_checker_missing");
+}
+var Editor = class {
+  constructor(builder, api, opts = {}) {
+    this.history = [];
+    this.index = -1;
+    // points to current snapshot
+    this.txnDepth = 0;
+    var _a, _b;
+    this.builder = builder;
+    this.api = api;
+    this.opts = {
+      historyLimit: Math.max(
+        1,
+        Math.min((_a = opts.historyLimit) != null ? _a : MAX_LIMIT, 1e3)
+      ),
+      validateAfterEach: (_b = opts.validateAfterEach) != null ? _b : false
+    };
+    this.pushHistory(this.makeSnapshot("init"));
+  }
+  /* ───────────────────────── Public API ───────────────────────── */
+  getProps() {
+    return this.builder.getProps();
+  }
+  transact(label, fn) {
+    const wasTop = this.txnDepth === 0;
+    let ok = false;
+    if (wasTop) {
+      this.txnLabel = label;
+      this.stagedBefore = this.makeSnapshot(label + ":before");
+    }
+    this.txnDepth++;
+    try {
+      fn();
+      ok = true;
+    } finally {
+      this.txnDepth--;
+      if (wasTop) {
+        if (ok) {
+          this.commit(label);
+        } else if (this.stagedBefore) {
+          this.loadSnapshot(this.stagedBefore, "undo");
+        }
+        this.txnLabel = void 0;
+        this.stagedBefore = void 0;
+      }
+    }
+  }
+  exec(cmd) {
+    var _a;
+    try {
+      const before = this.makeSnapshot(cmd.name + ":before");
+      cmd.do();
+      this.afterMutation(cmd.name, before);
+    } catch (err) {
+      this.emit("editor:error", {
+        message: (_a = err == null ? void 0 : err.message) != null ? _a : String(err),
+        code: "command"
+      });
+      throw err;
+    }
+  }
+  undo() {
+    if (this.index <= 0) return false;
+    this.index--;
+    this.loadSnapshot(this.history[this.index], "undo");
+    this.emit("editor:undo", {
+      stackSize: this.history.length,
+      index: this.index
+    });
+    return true;
+  }
+  redo() {
+    if (this.index >= this.history.length - 1) return false;
+    this.index++;
+    this.loadSnapshot(this.history[this.index], "redo");
+    this.emit("editor:redo", {
+      stackSize: this.history.length,
+      index: this.index
+    });
+    return true;
+  }
+  clearService(id) {
+    this.setService(id, { service_id: void 0 });
+  }
+  /* ───────────── Convenience editing ops (command-wrapped) ───────────── */
+  duplicate(ref, opts = {}) {
+    const snapBefore = this.makeSnapshot("duplicate:before");
+    try {
+      let newId = "";
+      this.transact("duplicate", () => {
+        if (ref.kind === "tag") {
+          newId = this.duplicateTag(ref.id, opts);
+        } else if (ref.kind === "field") {
+          newId = this.duplicateField(ref.id, opts);
+        } else {
+          newId = this.duplicateOption(ref.fieldId, ref.id, opts);
+        }
+      });
+      return newId;
+    } catch (err) {
+      this.loadSnapshot(snapBefore, "undo");
+      throw err;
+    }
+  }
+  /**
+   * Update the display label for a node and refresh the graph so node labels stay in sync.
+   * Supports: tag ("t:*"), field ("f:*"), option ("o:*").
+   * IDs are NOT changed; only the human-readable label.
+   */
+  reLabel(id, nextLabel) {
+    const label = String(nextLabel != null ? nextLabel : "").trim();
+    this.exec({
+      name: "reLabel",
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (isTagId(id)) {
+          const t = ((_a = p.filters) != null ? _a : []).find((x) => x.id === id);
+          if (!t) return;
+          if (((_b = t.label) != null ? _b : "") === label) return;
+          t.label = label;
+          this.api.refreshGraph();
+          return;
+        }
+        if (isOptionId(id)) {
+          const own = ownerOfOption(p, id);
+          if (!own) return;
+          const f = ((_c = p.fields) != null ? _c : []).find(
+            (x) => x.id === own.fieldId
+          );
+          const o = (_d = f == null ? void 0 : f.options) == null ? void 0 : _d.find((x) => x.id === id);
+          if (!o) return;
+          if (((_e = o.label) != null ? _e : "") === label) return;
+          o.label = label;
+          this.api.refreshGraph();
+          return;
+        }
+        const fld = ((_f = p.fields) != null ? _f : []).find((x) => x.id === id);
+        if (!fld) return;
+        if (((_g = fld.label) != null ? _g : "") === label) return;
+        fld.label = label;
+        this.api.refreshGraph();
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  /**
+   * Assign or change a field's `name`. Only allowed when the field (and its options) have NO service mapping.
+   * - If `nextName` is empty/blank → removes the `name`.
+   * - Emits an error if the field or any of its options carry a `service_id`.
+   * - Emits an error if `nextName` collides with an existing field's name (case-sensitive).
+   */
+  setFieldName(fieldId, nextName) {
+    const raw = typeof nextName === "string" ? nextName : "";
+    const name = raw.trim();
+    this.exec({
+      name: "setFieldName",
+      do: () => this.patchProps((p) => {
+        var _a;
+        const fields = (_a = p.fields) != null ? _a : [];
+        const f = fields.find((x) => x.id === fieldId);
+        if (!f) {
+          this.api.emit("error", {
+            code: "field_not_found",
+            message: `Field not found: ${fieldId}`,
+            meta: { fieldId }
+          });
+          return;
+        }
+        const fieldHasService = typeof f.service_id === "number";
+        const optionHasService = Array.isArray(f.options) ? f.options.some(
+          (o) => typeof o.service_id === "number"
+        ) : false;
+        if (fieldHasService || optionHasService) {
+          this.api.emit("error", {
+            code: "field_has_service_mapping",
+            message: "Cannot set a name on a field that maps to a service (either the field or one of its options has a service_id).",
+            meta: {
+              fieldId,
+              fieldHasService,
+              optionHasService
+            }
+          });
+          return;
+        }
+        if (name.length === 0) {
+          if ("name" in f) delete f.name;
+          return;
+        }
+        const collision = fields.find(
+          (x) => {
+            var _a2;
+            return x.id !== fieldId && ((_a2 = x.name) != null ? _a2 : "") === name;
+          }
+        );
+        if (collision) {
+          this.api.emit("error", {
+            code: "field_name_collision",
+            message: `Another field already uses the name "${name}".`,
+            meta: { fieldId, otherFieldId: collision.id }
+          });
+          return;
+        }
+        f.name = name;
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  getLastPolicyDiagnostics() {
+    return this._lastPolicyDiagnostics;
+  }
+  /* ───────────────────── Internals: duplicate impls ───────────────────── */
+  duplicateTag(tagId, opts) {
+    var _a, _b, _c, _d;
+    const props = this.builder.getProps();
+    const tags = (_a = props.filters) != null ? _a : [];
+    const src = tags.find((t) => t.id === tagId);
+    if (!src) throw new Error(`Tag not found: ${tagId}`);
+    const id = (_b = opts.id) != null ? _b : this.uniqueId(src.id);
+    const label = ((_c = opts.labelStrategy) != null ? _c : nextCopyLabel)((_d = src.label) != null ? _d : id);
+    if (!opts.withChildren) {
+      this.patchProps((p) => {
+        var _a2;
+        const clone = { ...src, id, label };
+        clone.bind_id = src.bind_id;
+        clone.constraints_overrides = void 0;
+        clone.constraints_origin = void 0;
+        const arr = (_a2 = p.filters) != null ? _a2 : [];
+        const idx = arr.findIndex((t) => t.id === tagId);
+        arr.splice(idx + 1, 0, clone);
+        p.filters = arr;
+      });
+      return id;
+    }
+    const idMap = /* @__PURE__ */ new Map();
+    const collect = (t, acc) => {
+      acc.push(t);
+      for (const child of tags.filter((x) => x.bind_id === t.id))
+        collect(child, acc);
+    };
+    const subtree = [];
+    collect(src, subtree);
+    for (const n of subtree)
+      idMap.set(n.id, n.id === src.id ? id : this.uniqueId(n.id));
+    const clones = subtree.map((n) => {
+      var _a2, _b2, _c2;
+      const cloned = { ...n };
+      cloned.id = idMap.get(n.id);
+      cloned.label = n.id === src.id ? label : ((_a2 = opts.labelStrategy) != null ? _a2 : nextCopyLabel)((_b2 = n.label) != null ? _b2 : n.id);
+      cloned.bind_id = n.bind_id ? (_c2 = idMap.get(n.bind_id)) != null ? _c2 : n.bind_id : void 0;
+      cloned.constraints_origin = void 0;
+      cloned.constraints_overrides = void 0;
+      return cloned;
+    });
+    this.patchProps((p) => {
+      var _a2;
+      const arr = (_a2 = p.filters) != null ? _a2 : [];
+      const rootIdx = arr.findIndex((t) => t.id === tagId);
+      arr.splice(rootIdx + 1, 0, clones[0]);
+      for (const c of clones.slice(1)) arr.push(c);
+      p.filters = arr;
+    });
+    return id;
+  }
+  duplicateField(fieldId, opts) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const props = this.builder.getProps();
+    const fields = (_a = props.fields) != null ? _a : [];
+    const src = fields.find((f) => f.id === fieldId);
+    if (!src) throw new Error(`Field not found: ${fieldId}`);
+    const id = (_b = opts.id) != null ? _b : this.uniqueId(src.id);
+    const label = ((_c = opts.labelStrategy) != null ? _c : nextCopyLabel)((_d = src.label) != null ? _d : id);
+    const name = opts.nameStrategy ? opts.nameStrategy(src.name) : nextCopyName(src.name);
+    const optId = (old) => {
+      var _a2;
+      return this.uniqueOptionId(
+        id,
+        ((_a2 = opts.optionIdStrategy) != null ? _a2 : defaultOptionIdStrategy)(old)
+      );
+    };
+    const clonedOptions = ((_e = src.options) != null ? _e : []).map((o) => {
+      var _a2, _b2;
+      return {
+        ...o,
+        id: optId(o.id),
+        label: ((_a2 = opts.labelStrategy) != null ? _a2 : nextCopyLabel)((_b2 = o.label) != null ? _b2 : o.id)
+      };
+    });
+    const cloned = {
+      ...src,
+      id,
+      label,
+      name,
+      bind_id: ((_f = opts.copyBindings) != null ? _f : true) ? src.bind_id : void 0,
+      options: clonedOptions
+    };
+    const optionIdMap = /* @__PURE__ */ new Map();
+    ((_g = src.options) != null ? _g : []).forEach((o, i) => {
+      var _a2, _b2;
+      const newOptId = (_b2 = (_a2 = clonedOptions[i]) == null ? void 0 : _a2.id) != null ? _b2 : o.id;
+      optionIdMap.set(o.id, newOptId);
+    });
+    this.patchProps((p) => {
+      var _a2, _b2, _c2, _d2, _e2, _f2, _g2;
+      const arr = (_a2 = p.fields) != null ? _a2 : [];
+      const idx = arr.findIndex((f) => f.id === fieldId);
+      arr.splice(idx + 1, 0, cloned);
+      p.fields = arr;
+      if (opts.copyIncludesExcludes) {
+        for (const t of (_b2 = p.filters) != null ? _b2 : []) {
+          if ((_c2 = t.includes) == null ? void 0 : _c2.includes(fieldId)) {
+            const s = new Set(t.includes);
+            s.add(id);
+            t.includes = Array.from(s);
+          }
+          if ((_d2 = t.excludes) == null ? void 0 : _d2.includes(fieldId)) {
+            const s = new Set(t.excludes);
+            s.add(id);
+            t.excludes = Array.from(s);
+          }
+        }
+      }
+      if (opts.copyOptionMaps) {
+        const maps = ["includes_for_buttons", "excludes_for_buttons"];
+        for (const mapKey of maps) {
+          const srcMap = (_e2 = p[mapKey]) != null ? _e2 : {};
+          const nextMap = { ...srcMap };
+          for (const [key, targets] of Object.entries(
+            srcMap
+          )) {
+            if (key === fieldId) {
+              const newKey = id;
+              const merged = /* @__PURE__ */ new Set([
+                ...(_f2 = nextMap[newKey]) != null ? _f2 : [],
+                ...targets
+              ]);
+              nextMap[newKey] = Array.from(merged);
+              continue;
+            }
+            if (optionIdMap.has(key)) {
+              const newKey = optionIdMap.get(key);
+              const merged = /* @__PURE__ */ new Set([
+                ...(_g2 = nextMap[newKey]) != null ? _g2 : [],
+                ...targets
+              ]);
+              nextMap[newKey] = Array.from(merged);
+            }
+          }
+          p[mapKey] = nextMap;
+        }
+      }
+    });
+    return id;
+  }
+  duplicateOption(fieldId, optionId, opts) {
+    var _a, _b, _c, _d, _e, _f;
+    const props = this.builder.getProps();
+    const fields = (_a = props.fields) != null ? _a : [];
+    const f = fields.find((x) => x.id === fieldId);
+    if (!f) throw new Error(`Field not found: ${fieldId}`);
+    const optIdx = ((_b = f.options) != null ? _b : []).findIndex((o) => o.id === optionId);
+    if (optIdx < 0)
+      throw new Error(`Option not found: ${fieldId}::${optionId}`);
+    const src = ((_c = f.options) != null ? _c : [])[optIdx];
+    const newId = this.uniqueOptionId(
+      fieldId,
+      ((_d = opts.optionIdStrategy) != null ? _d : defaultOptionIdStrategy)(src.id)
+    );
+    const newLabel = ((_e = opts.labelStrategy) != null ? _e : nextCopyLabel)(
+      (_f = src.label) != null ? _f : src.id
+    );
+    this.patchProps((p) => {
+      var _a2, _b2, _c2;
+      const fld = ((_a2 = p.fields) != null ? _a2 : []).find((x) => x.id === fieldId);
+      const arr = (_b2 = fld.options) != null ? _b2 : [];
+      const clone = { ...src, id: newId, label: newLabel };
+      arr.splice(optIdx + 1, 0, clone);
+      fld.options = arr;
+      if (opts.copyOptionMaps) {
+        const oldKey = `${fieldId}::${optionId}`;
+        const newKey = `${fieldId}::${newId}`;
+        for (const mapKey of [
+          "includes_for_buttons",
+          "excludes_for_buttons"
+        ]) {
+          const m = (_c2 = p[mapKey]) != null ? _c2 : {};
+          if (m[oldKey]) {
+            m[newKey] = Array.from(new Set(m[oldKey]));
+            p[mapKey] = m;
+          }
+        }
+      }
+    });
+    return newId;
+  }
+  /* ───────────────────── Helpers: uniqueness & naming ───────────────────── */
+  uniqueId(base) {
+    var _a, _b;
+    const props = this.builder.getProps();
+    const taken = /* @__PURE__ */ new Set([
+      ...((_a = props.filters) != null ? _a : []).map((t) => t.id),
+      ...((_b = props.fields) != null ? _b : []).map((f) => f.id)
+    ]);
+    let candidate = nextCopyId(base);
+    while (taken.has(candidate)) candidate = bumpSuffix(candidate);
+    return candidate;
+  }
+  uniqueOptionId(fieldId, base) {
+    var _a, _b;
+    const props = this.builder.getProps();
+    const fld = ((_a = props.fields) != null ? _a : []).find((f) => f.id === fieldId);
+    const taken = new Set(((_b = fld == null ? void 0 : fld.options) != null ? _b : []).map((o) => o.id));
+    let candidate = base;
+    if (taken.has(candidate)) candidate = nextCopyId(candidate);
+    while (taken.has(candidate)) candidate = bumpSuffix(candidate);
+    return candidate;
+  }
+  //---------
+  /**
+   * Reorder a node:
+   * - Tag: among its siblings (same bind_id) inside filters[]
+   * - Field: inside order_for_tags[scopeTagId] (you must pass scopeTagId)
+   * - Option: use placeOption() instead
+   */
+  placeNode(id, opts) {
+    if (isTagId(id)) {
+      this.exec({
+        name: "placeTag",
+        do: () => this.patchProps((p) => {
+          var _a, _b, _c;
+          const all = (_a = p.filters) != null ? _a : [];
+          const cur = all.find((t) => t.id === id);
+          if (!cur) return;
+          const groupKey = (_b = cur.bind_id) != null ? _b : "__root__";
+          const siblings = all.filter(
+            (t) => {
+              var _a2;
+              return ((_a2 = t.bind_id) != null ? _a2 : "__root__") === groupKey;
+            }
+          );
+          const curIdx = siblings.findIndex((t) => t.id === id);
+          if (curIdx < 0) return;
+          const pulled = siblings.splice(curIdx, 1)[0];
+          let dest = typeof opts.index === "number" ? opts.index : void 0;
+          if (opts.beforeId)
+            dest = Math.max(
+              0,
+              siblings.findIndex(
+                (t) => t.id === opts.beforeId
+              )
+            );
+          if (opts.afterId)
+            dest = Math.min(
+              siblings.length,
+              siblings.findIndex(
+                (t) => t.id === opts.afterId
+              ) + 1
+            );
+          if (dest === void 0 || Number.isNaN(dest))
+            dest = siblings.length;
+          const out = [];
+          for (const t of all) {
+            const sameGroup = ((_c = t.bind_id) != null ? _c : "__root__") === groupKey;
+            if (!sameGroup) {
+              out.push(t);
+            }
+          }
+          siblings.splice(dest, 0, pulled);
+          p.filters = [...out, ...siblings];
+        }),
+        undo: () => this.api.undo()
+      });
+    } else if (isFieldId(id)) {
+      if (!opts.scopeTagId)
+        throw new Error("placeNode(field): scopeTagId is required");
+      const fieldId = id;
+      const tagId = opts.scopeTagId;
+      this.exec({
+        name: "placeField",
+        do: () => this.patchProps((p) => {
+          var _a, _b;
+          const map = (_a = p.order_for_tags) != null ? _a : p.order_for_tags = {};
+          const arr = (_b = map[tagId]) != null ? _b : map[tagId] = [];
+          const curIdx = arr.indexOf(fieldId);
+          if (curIdx >= 0) arr.splice(curIdx, 1);
+          let dest = typeof opts.index === "number" ? opts.index : void 0;
+          if (opts.beforeId)
+            dest = Math.max(0, arr.indexOf(opts.beforeId));
+          if (opts.afterId)
+            dest = Math.min(
+              arr.length,
+              arr.indexOf(opts.afterId) + 1
+            );
+          if (dest === void 0 || Number.isNaN(dest))
+            dest = arr.length;
+          arr.splice(dest, 0, fieldId);
+        }),
+        undo: () => this.api.undo()
+      });
+    } else if (isOptionId(id)) {
+      this.placeOption(id, opts);
+    } else {
+      throw new Error("placeNode: unknown id prefix");
+    }
+  }
+  placeOption(optionId, opts) {
+    if (!isOptionId(optionId))
+      throw new Error('placeOption: optionId must start with "o:"');
+    this.exec({
+      name: "placeOption",
+      do: () => this.patchProps((p) => {
+        var _a;
+        const owner = ownerOfOption(p, optionId);
+        if (!owner) return;
+        const f = ((_a = p.fields) != null ? _a : []).find(
+          (x) => x.id === owner.fieldId
+        );
+        if (!(f == null ? void 0 : f.options)) return;
+        const curIdx = f.options.findIndex(
+          (o) => o.id === optionId
+        );
+        if (curIdx < 0) return;
+        const pulled = f.options.splice(curIdx, 1)[0];
+        let dest = typeof opts.index === "number" ? opts.index : void 0;
+        if (opts.beforeId)
+          dest = Math.max(
+            0,
+            f.options.findIndex((o) => o.id === opts.beforeId)
+          );
+        if (opts.afterId)
+          dest = Math.min(
+            f.options.length,
+            f.options.findIndex((o) => o.id === opts.afterId) + 1
+          );
+        if (dest === void 0 || Number.isNaN(dest))
+          dest = f.options.length;
+        f.options.splice(dest, 0, pulled);
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  addOption(fieldId, input) {
+    var _a;
+    const id = (_a = input.id) != null ? _a : this.genId("o");
+    this.exec({
+      name: "addOption",
+      do: () => this.patchProps((p) => {
+        var _a2, _b;
+        const f = ((_a2 = p.fields) != null ? _a2 : []).find((x) => x.id === fieldId);
+        if (!f)
+          throw new Error(
+            `addOption: field '${fieldId}' not found`
+          );
+        const list = (_b = f.options) != null ? _b : f.options = [];
+        if (list.some((o) => o.id === id))
+          throw new Error(`Option id '${id}' already exists`);
+        list.push({ ...input, id });
+      }),
+      undo: () => this.api.undo()
+    });
+    return id;
+  }
+  updateOption(optionId, patch) {
+    if (!isOptionId(optionId))
+      throw new Error('updateOption: optionId must start with "o:"');
+    this.exec({
+      name: "updateOption",
+      do: () => this.patchProps((p) => {
+        var _a;
+        const owner = ownerOfOption(p, optionId);
+        if (!owner) return;
+        const f = ((_a = p.fields) != null ? _a : []).find(
+          (x) => x.id === owner.fieldId
+        );
+        if (!(f == null ? void 0 : f.options)) return;
+        const o = f.options.find((x) => x.id === optionId);
+        if (o) Object.assign(o, patch);
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  removeOption(optionId) {
+    if (!isOptionId(optionId))
+      throw new Error('removeOption: optionId must start with "o:"');
+    this.exec({
+      name: "removeOption",
+      do: () => this.patchProps((p) => {
+        var _a;
+        const owner = ownerOfOption(p, optionId);
+        if (!owner) return;
+        const f = ((_a = p.fields) != null ? _a : []).find(
+          (x) => x.id === owner.fieldId
+        );
+        if (!(f == null ? void 0 : f.options)) return;
+        f.options = f.options.filter((o) => o.id !== optionId);
+        const maps = ["includes_for_options", "excludes_for_options"];
+        for (const m of maps) {
+          const map = p[m];
+          if (!map) continue;
+          if (map[optionId]) delete map[optionId];
+          if (!Object.keys(map).length) delete p[m];
+        }
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  editLabel(id, label) {
+    const next = (label != null ? label : "").trim();
+    if (!next) throw new Error("Label cannot be empty");
+    this.exec({
+      name: "editLabel",
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d;
+        if (isTagId(id)) {
+          const t = ((_a = p.filters) != null ? _a : []).find((x) => x.id === id);
+          if (t) t.label = next;
+          return;
+        }
+        if (isFieldId(id)) {
+          const f = ((_b = p.fields) != null ? _b : []).find((x) => x.id === id);
+          if (f) f.label = next;
+          return;
+        }
+        if (isOptionId(id)) {
+          const own = ownerOfOption(p, id);
+          if (!own) return;
+          const f = ((_c = p.fields) != null ? _c : []).find(
+            (x) => x.id === own.fieldId
+          );
+          const o = (_d = f == null ? void 0 : f.options) == null ? void 0 : _d.find((x) => x.id === id);
+          if (o) o.label = next;
+          return;
+        }
+        throw new Error("editLabel: unsupported id");
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  editName(fieldId, name) {
+    this.exec({
+      name: "editName",
+      do: () => this.patchProps((p) => {
+        var _a;
+        const f = ((_a = p.fields) != null ? _a : []).find((x) => x.id === fieldId);
+        if (!f) return;
+        f.name = name;
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  setService(id, input) {
+    this.exec({
+      name: "setService",
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d, _e, _f;
+        const hasSidKey = Object.prototype.hasOwnProperty.call(
+          input,
+          "service_id"
+        );
+        const validId = hasSidKey && typeof input.service_id === "number" && Number.isFinite(input.service_id);
+        const sid = validId ? Number(input.service_id) : void 0;
+        const nextRole = input.pricing_role;
+        if (isTagId(id)) {
+          const t = ((_a = p.filters) != null ? _a : []).find((x) => x.id === id);
+          if (!t) return;
+          if (hasSidKey) {
+            if (sid === void 0) delete t.service_id;
+            else t.service_id = sid;
+          }
+          return;
+        }
+        if (isOptionId(id)) {
+          const own = ownerOfOption(p, id);
+          if (!own) return;
+          const f2 = ((_b = p.fields) != null ? _b : []).find(
+            (x) => x.id === own.fieldId
+          );
+          const o = (_c = f2 == null ? void 0 : f2.options) == null ? void 0 : _c.find((x) => x.id === id);
+          if (!o) return;
+          const currentRole = (_d = o.pricing_role) != null ? _d : "base";
+          const role = nextRole != null ? nextRole : currentRole;
+          if (role === "utility") {
+            if (hasSidKey && sid !== void 0) {
+              this.api.emit("error", {
+                message: "Utilities cannot have service_id (option).",
+                code: "utility_service_conflict",
+                meta: { id, service_id: sid }
+              });
+            }
+            o.pricing_role = "utility";
+            if ("service_id" in o) delete o.service_id;
+            return;
+          }
+          if (nextRole) o.pricing_role = "base";
+          if (hasSidKey) {
+            if (sid === void 0) delete o.service_id;
+            else o.service_id = sid;
+          }
+          return;
+        }
+        const f = ((_e = p.fields) != null ? _e : []).find((x) => x.id === id);
+        if (!f) {
+          throw new Error(
+            'setService only supports tag ("t:*"), option ("o:*"), or field ("f:*") ids'
+          );
+        }
+        const isOptionBased = Array.isArray(f.options) && f.options.length > 0;
+        const isButton = !!f.button;
+        if (nextRole) {
+          f.pricing_role = nextRole;
+        }
+        const effectiveRole = (_f = f.pricing_role) != null ? _f : "base";
+        if (isOptionBased) {
+          if (hasSidKey) {
+            this.api.emit("error", {
+              message: "Cannot set service_id on an option-based field. Assign service_id on its options instead.",
+              code: "field_option_based_service_forbidden",
+              meta: { id, service_id: sid }
+            });
+          }
+          if ("service_id" in f)
+            delete f.service_id;
+          return;
+        }
+        if (!isButton) {
+          if (hasSidKey) {
+            this.api.emit("error", {
+              message: "Only button fields (without options) can have a service_id.",
+              code: "non_button_field_service_forbidden",
+              meta: { id, service_id: sid }
+            });
+          }
+          if ("service_id" in f)
+            delete f.service_id;
+          return;
+        }
+        if (effectiveRole === "utility") {
+          if (hasSidKey && sid !== void 0) {
+            this.api.emit("error", {
+              message: "Utilities cannot have service_id (field).",
+              code: "utility_service_conflict",
+              meta: { id, service_id: sid }
+            });
+          }
+          if ("service_id" in f)
+            delete f.service_id;
+          return;
+        }
+        if (hasSidKey) {
+          if (sid === void 0) delete f.service_id;
+          else f.service_id = sid;
+        }
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  addTag(partial) {
+    var _a;
+    const id = (_a = partial.id) != null ? _a : this.genId("t");
+    const payload = { ...partial, id };
+    this.exec({
+      name: "addTag",
+      do: () => this.patchProps((p) => {
+        var _a2;
+        p.filters = [...(_a2 = p.filters) != null ? _a2 : [], payload];
+      }),
+      undo: () => this.patchProps((p) => {
+        var _a2;
+        p.filters = ((_a2 = p.filters) != null ? _a2 : []).filter((t) => t.id !== id);
+      })
+    });
+  }
+  updateTag(id, patch) {
+    let prev;
+    this.exec({
+      name: "updateTag",
+      do: () => this.patchProps((p) => {
+        var _a;
+        p.filters = ((_a = p.filters) != null ? _a : []).map((t) => {
+          if (t.id !== id) return t;
+          prev = t;
+          return { ...t, ...patch };
+        });
+      }),
+      undo: () => this.patchProps((p) => {
+        var _a;
+        p.filters = ((_a = p.filters) != null ? _a : []).map(
+          (t) => t.id === id && prev ? prev : t
+        );
+      })
+    });
+  }
+  removeTag(id) {
+    let prevSlice;
+    this.exec({
+      name: "removeTag",
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d, _e;
+        prevSlice = (0, import_lodash_es2.cloneDeep)(p);
+        p.filters = ((_a = p.filters) != null ? _a : []).filter((t) => t.id !== id);
+        for (const t of (_b = p.filters) != null ? _b : []) {
+          if (t.bind_id === id) delete t.bind_id;
+          t.includes = ((_c = t.includes) != null ? _c : []).filter((x) => x !== id);
+          t.excludes = ((_d = t.excludes) != null ? _d : []).filter((x) => x !== id);
+        }
+        for (const f of (_e = p.fields) != null ? _e : []) {
+          if (Array.isArray(f.bind_id))
+            f.bind_id = f.bind_id.filter((x) => x !== id);
+          else if (f.bind_id === id) delete f.bind_id;
+        }
+      }),
+      undo: () => this.replaceProps(prevSlice)
+    });
+  }
+  addField(partial) {
+    var _a;
+    const id = (_a = partial.id) != null ? _a : this.genId("f");
+    const payload = { ...partial, id };
+    this.exec({
+      name: "addField",
+      do: () => this.patchProps((p) => {
+        var _a2;
+        p.fields = [...(_a2 = p.fields) != null ? _a2 : [], payload];
+      }),
+      undo: () => this.patchProps((p) => {
+        var _a2;
+        p.fields = ((_a2 = p.fields) != null ? _a2 : []).filter((f) => f.id !== id);
+      })
+    });
+  }
+  updateField(id, patch) {
+    let prev;
+    this.exec({
+      name: "updateField",
+      do: () => this.patchProps((p) => {
+        var _a;
+        p.fields = ((_a = p.fields) != null ? _a : []).map((f) => {
+          if (f.id !== id) return f;
+          prev = f;
+          return { ...f, ...patch };
+        });
+      }),
+      undo: () => this.patchProps((p) => {
+        var _a;
+        p.fields = ((_a = p.fields) != null ? _a : []).map(
+          (f) => f.id === id && prev ? prev : f
+        );
+      })
+    });
+  }
+  removeField(id) {
+    let prevSlice;
+    this.exec({
+      name: "removeField",
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d, _e, _f;
+        prevSlice = (0, import_lodash_es2.cloneDeep)(p);
+        p.fields = ((_a = p.fields) != null ? _a : []).filter((f) => f.id !== id);
+        for (const mapKey of [
+          "includes_for_buttons",
+          "excludes_for_buttons"
+        ]) {
+          const m = p[mapKey];
+          if (!m) continue;
+          for (const k of Object.keys(m)) {
+            m[k] = ((_b = m[k]) != null ? _b : []).filter((fid) => fid !== id);
+            if (!((_c = m[k]) == null ? void 0 : _c.length)) delete m[k];
+          }
+        }
+        for (const t of (_d = p.filters) != null ? _d : []) {
+          t.includes = ((_e = t.includes) != null ? _e : []).filter((x) => x !== id);
+          t.excludes = ((_f = t.excludes) != null ? _f : []).filter((x) => x !== id);
+        }
+      }),
+      undo: () => this.replaceProps(prevSlice)
+    });
+  }
+  remove(id) {
+    if (isTagId(id)) {
+      this.exec({
+        name: "removeTag",
+        do: () => this.patchProps((p) => {
+          var _a, _b, _c, _d, _e, _f, _g, _h;
+          p.filters = ((_a = p.filters) != null ? _a : []).filter(
+            (t) => t.id !== id
+          );
+          for (const t of (_b = p.filters) != null ? _b : []) {
+            if (t.bind_id === id) delete t.bind_id;
+            t.includes = ((_c = t.includes) != null ? _c : []).filter(
+              (x) => x !== id
+            );
+            t.excludes = ((_d = t.excludes) != null ? _d : []).filter(
+              (x) => x !== id
+            );
+          }
+          for (const f of (_e = p.fields) != null ? _e : []) {
+            if (Array.isArray(f.bind_id))
+              f.bind_id = f.bind_id.filter(
+                (x) => x !== id
+              );
+            else if (f.bind_id === id) delete f.bind_id;
+          }
+          if ((_f = p.order_for_tags) == null ? void 0 : _f[id]) delete p.order_for_tags[id];
+          for (const k of Object.keys((_g = p.order_for_tags) != null ? _g : {})) {
+            p.order_for_tags[k] = ((_h = p.order_for_tags[k]) != null ? _h : []).filter(
+              (fid) => {
+                var _a2;
+                return ((_a2 = p.fields) != null ? _a2 : []).some((f) => f.id === fid);
+              }
+            );
+            if (!p.order_for_tags[k].length)
+              delete p.order_for_tags[k];
+          }
+        }),
+        undo: () => this.api.undo()
+      });
+      return;
+    }
+    if (isFieldId(id)) {
+      this.exec({
+        name: "removeField",
+        do: () => this.patchProps((p) => {
+          var _a, _b, _c, _d, _e, _f, _g, _h;
+          p.fields = ((_a = p.fields) != null ? _a : []).filter((f) => f.id !== id);
+          for (const t of (_b = p.filters) != null ? _b : []) {
+            t.includes = ((_c = t.includes) != null ? _c : []).filter(
+              (x) => x !== id
+            );
+            t.excludes = ((_d = t.excludes) != null ? _d : []).filter(
+              (x) => x !== id
+            );
+          }
+          for (const k of Object.keys((_e = p.order_for_tags) != null ? _e : {})) {
+            p.order_for_tags[k] = ((_f = p.order_for_tags[k]) != null ? _f : []).filter((fid) => fid !== id);
+            if (!p.order_for_tags[k].length)
+              delete p.order_for_tags[k];
+          }
+          const maps = ["includes_for_options", "excludes_for_options"];
+          for (const m of maps) {
+            const map = p[m];
+            if (!map) continue;
+            for (const key of Object.keys(map)) {
+              map[key] = ((_g = map[key]) != null ? _g : []).filter(
+                (fid) => fid !== id
+              );
+              if (!((_h = map[key]) == null ? void 0 : _h.length)) delete map[key];
+            }
+            if (!Object.keys(map).length) delete p[m];
+          }
+        }),
+        undo: () => this.api.undo()
+      });
+      return;
+    }
+    if (isOptionId(id)) {
+      this.removeOption(id);
+      return;
+    }
+    throw new Error("remove: unknown id prefix");
+  }
+  getNode(id) {
+    var _a, _b, _c, _d;
+    const props = this.builder.getProps();
+    if (isTagId(id)) {
+      const t = ((_a = props.filters) != null ? _a : []).find((x) => x.id === id);
+      return {
+        kind: "tag",
+        data: t,
+        owners: { parentTagId: t == null ? void 0 : t.bind_id }
+      };
+    }
+    if (isFieldId(id)) {
+      const f = ((_b = props.fields) != null ? _b : []).find((x) => x.id === id);
+      const bind = Array.isArray(f == null ? void 0 : f.bind_id) ? f.bind_id : (f == null ? void 0 : f.bind_id) ? [f.bind_id] : [];
+      return { kind: "field", data: f, owners: { bindTagIds: bind } };
+    }
+    if (isOptionId(id)) {
+      const own = ownerOfOption(props, id);
+      const f = own ? ((_c = props.fields) != null ? _c : []).find((x) => x.id === own.fieldId) : void 0;
+      const o = (_d = f == null ? void 0 : f.options) == null ? void 0 : _d.find((x) => x.id === id);
+      return {
+        kind: "option",
+        data: o,
+        owners: { fieldId: own == null ? void 0 : own.fieldId }
+      };
+    }
+    return { kind: "option", data: void 0, owners: {} };
+  }
+  getFieldQuantityRule(id) {
+    var _a, _b;
+    const props = this.builder.getProps();
+    const f = ((_a = props.fields) != null ? _a : []).find((x) => x.id === id);
+    if (!f) return void 0;
+    return normalizeQuantityRule((_b = f.meta) == null ? void 0 : _b.quantity);
+  }
+  setFieldQuantityRule(id, rule) {
+    this.exec({
+      name: "setFieldQuantityRule",
+      do: () => this.patchProps((p) => {
+        var _a, _b;
+        const f = ((_a = p.fields) != null ? _a : []).find((x) => x.id === id);
+        if (!f) return;
+        const normalized = normalizeQuantityRule(rule);
+        if (!normalized) {
+          if (((_b = f.meta) == null ? void 0 : _b.quantity) !== void 0) {
+            delete f.meta.quantity;
+            if (f.meta && Object.keys(f.meta).length === 0) {
+              delete f.meta;
+            }
+          }
+          return;
+        }
+        f.meta = {
+          ...f.meta,
+          quantity: normalized
+        };
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  clearFieldQuantityRule(id) {
+    this.exec({
+      name: "clearFieldQuantityRule",
+      do: () => this.patchProps((p) => {
+        var _a, _b;
+        const f = ((_a = p.fields) != null ? _a : []).find((x) => x.id === id);
+        if (!f || !((_b = f.meta) == null ? void 0 : _b.quantity)) return;
+        delete f.meta.quantity;
+        if (f.meta && Object.keys(f.meta).length === 0) {
+          delete f.meta;
+        }
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  /** Walk ancestors for a tag and detect if parent→child would create a cycle */
+  wouldCreateTagCycle(p, parentId, childId) {
+    var _a, _b;
+    if (parentId === childId) return true;
+    const tagById = new Map(((_a = p.filters) != null ? _a : []).map((t) => [t.id, t]));
+    let cur = parentId;
+    const guard = /* @__PURE__ */ new Set();
+    while (cur) {
+      if (cur === childId) return true;
+      if (guard.has(cur)) break;
+      guard.add(cur);
+      cur = (_b = tagById.get(cur)) == null ? void 0 : _b.bind_id;
+    }
+    return false;
+  }
+  wouldCreateIncludeExcludeCycle(p, receiverId, targetId) {
+    if (receiverId === targetId) return true;
+    const getDirectRelations = (id) => {
+      var _a, _b, _c, _d, _e, _f, _g;
+      if (isTagId(id)) {
+        const t = ((_a = p.filters) != null ? _a : []).find((x) => x.id === id);
+        return [...(_b = t == null ? void 0 : t.includes) != null ? _b : [], ...(_c = t == null ? void 0 : t.excludes) != null ? _c : []];
+      }
+      const inc = (_e = (_d = p.includes_for_buttons) == null ? void 0 : _d[id]) != null ? _e : [];
+      const exc = (_g = (_f = p.excludes_for_buttons) == null ? void 0 : _f[id]) != null ? _g : [];
+      return [...inc, ...exc];
+    };
+    const visited = /* @__PURE__ */ new Set();
+    const stack = [targetId];
+    while (stack.length > 0) {
+      const curr = stack.pop();
+      if (curr === receiverId) return true;
+      if (visited.has(curr)) continue;
+      visited.add(curr);
+      stack.push(...getDirectRelations(curr));
+    }
+    return false;
+  }
+  include(receiverId, idOrIds) {
+    this.exec({
+      name: "include",
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const receiver = this.getNode(receiverId);
+        const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
+        if (receiver.kind === "tag" || receiver.kind === "field" && ((_a = receiver.data) == null ? void 0 : _a.button) || receiver.kind === "option") {
+          if (receiver.kind === "tag") {
+            const t = ((_b = p.filters) != null ? _b : []).find(
+              (x) => x.id === receiverId
+            );
+            if (t) {
+              const accepted = [];
+              const next = new Set((_c = t.includes) != null ? _c : []);
+              for (const id of ids) {
+                if (this.wouldCreateIncludeExcludeCycle(
+                  p,
+                  receiverId,
+                  id
+                )) {
+                  this.emit("editor:error", {
+                    message: `Cycle detected: ${receiverId} including ${id} would create a cycle.`,
+                    code: "cycle_detected",
+                    meta: {
+                      receiverId,
+                      targetId: id,
+                      type: "include"
+                    }
+                  });
+                  continue;
+                }
+                next.add(id);
+                accepted.push(id);
+              }
+              if (accepted.length > 0 || ((_e = (_d = t.includes) == null ? void 0 : _d.length) != null ? _e : 0) > 0) {
+                t.includes = Array.from(next);
+              }
+              if (t.excludes) {
+                t.excludes = t.excludes.filter(
+                  (x) => !accepted.includes(x)
+                );
+                if (t.excludes.length === 0) {
+                  delete t.excludes;
+                }
+              }
+            }
+          } else {
+            const accepted = [];
+            const current = (_g = (_f = p.includes_for_buttons) == null ? void 0 : _f[receiverId]) != null ? _g : [];
+            const next = new Set(current);
+            for (const id of ids) {
+              if (this.wouldCreateIncludeExcludeCycle(
+                p,
+                receiverId,
+                id
+              )) {
+                this.emit("editor:error", {
+                  message: `Cycle detected: ${receiverId} including ${id} would create a cycle.`,
+                  code: "cycle_detected",
+                  meta: {
+                    receiverId,
+                    targetId: id,
+                    type: "include"
+                  }
+                });
+                continue;
+              }
+              next.add(id);
+              accepted.push(id);
+            }
+            if (accepted.length > 0 || current.length > 0) {
+              if (!p.includes_for_buttons)
+                p.includes_for_buttons = {};
+              p.includes_for_buttons[receiverId] = Array.from(next);
+            }
+            if ((_h = p.excludes_for_buttons) == null ? void 0 : _h[receiverId]) {
+              p.excludes_for_buttons[receiverId] = p.excludes_for_buttons[receiverId].filter(
+                (x) => !accepted.includes(x)
+              );
+              if (p.excludes_for_buttons[receiverId].length === 0) {
+                delete p.excludes_for_buttons[receiverId];
+              }
+            }
+          }
+          if (!p.fields) p.fields = [];
+          if (!p.filters) p.filters = [];
+        } else {
+          throw new Error(
+            "Receiver must be a tag, button field, or option"
+          );
+        }
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  exclude(receiverId, idOrIds) {
+    this.exec({
+      name: "exclude",
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const receiver = this.getNode(receiverId);
+        const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
+        if (receiver.kind === "tag" || receiver.kind === "field" && ((_a = receiver.data) == null ? void 0 : _a.button) || receiver.kind === "option") {
+          if (receiver.kind === "tag") {
+            const t = ((_b = p.filters) != null ? _b : []).find(
+              (x) => x.id === receiverId
+            );
+            if (t) {
+              const accepted = [];
+              const next = new Set((_c = t.excludes) != null ? _c : []);
+              for (const id of ids) {
+                if (this.wouldCreateIncludeExcludeCycle(
+                  p,
+                  receiverId,
+                  id
+                )) {
+                  this.emit("editor:error", {
+                    message: `Cycle detected: ${receiverId} excluding ${id} would create a cycle.`,
+                    code: "cycle_detected",
+                    meta: {
+                      receiverId,
+                      targetId: id,
+                      type: "exclude"
+                    }
+                  });
+                  continue;
+                }
+                next.add(id);
+                accepted.push(id);
+              }
+              if (accepted.length > 0 || ((_e = (_d = t.excludes) == null ? void 0 : _d.length) != null ? _e : 0) > 0) {
+                t.excludes = Array.from(next);
+              }
+              if (t.includes) {
+                t.includes = t.includes.filter(
+                  (x) => !accepted.includes(x)
+                );
+                if (t.includes.length === 0) {
+                  delete t.includes;
+                }
+              }
+            }
+          } else {
+            const accepted = [];
+            const current = (_g = (_f = p.excludes_for_buttons) == null ? void 0 : _f[receiverId]) != null ? _g : [];
+            const next = new Set(current);
+            for (const id of ids) {
+              if (this.wouldCreateIncludeExcludeCycle(
+                p,
+                receiverId,
+                id
+              )) {
+                this.emit("editor:error", {
+                  message: `Cycle detected: ${receiverId} excluding ${id} would create a cycle.`,
+                  code: "cycle_detected",
+                  meta: {
+                    receiverId,
+                    targetId: id,
+                    type: "exclude"
+                  }
+                });
+                continue;
+              }
+              next.add(id);
+              accepted.push(id);
+            }
+            if (accepted.length > 0 || current.length > 0) {
+              if (!p.excludes_for_buttons)
+                p.excludes_for_buttons = {};
+              p.excludes_for_buttons[receiverId] = Array.from(next);
+            }
+            if ((_h = p.includes_for_buttons) == null ? void 0 : _h[receiverId]) {
+              p.includes_for_buttons[receiverId] = p.includes_for_buttons[receiverId].filter(
+                (x) => !accepted.includes(x)
+              );
+              if (p.includes_for_buttons[receiverId].length === 0) {
+                delete p.includes_for_buttons[receiverId];
+              }
+            }
+          }
+          if (!p.fields) p.fields = [];
+          if (!p.filters) p.filters = [];
+        } else {
+          throw new Error(
+            "Receiver must be a tag, button field, or option"
+          );
+        }
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  /* ──────────────────────────────────────────────────────────────────────────
+   * CONNECT
+   * ────────────────────────────────────────────────────────────────────────── */
+  connect(kind, fromId, toId) {
+    this.exec({
+      name: `connect:${kind}`,
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d, _e;
+        if (kind === "bind") {
+          if (isTagId(fromId) && isTagId(toId)) {
+            if (this.wouldCreateTagCycle(p, fromId, toId)) {
+              throw new Error(
+                `bind would create a cycle: ${fromId} \u2192 ${toId}`
+              );
+            }
+            const child = ((_a = p.filters) != null ? _a : []).find(
+              (t) => t.id === toId
+            );
+            if (child) child.bind_id = fromId;
+            return;
+          }
+          if (isTagId(fromId) && isFieldId(toId) || isFieldId(fromId) && isTagId(toId)) {
+            const fieldId = isFieldId(toId) ? toId : fromId;
+            const tagId = isTagId(fromId) ? fromId : toId;
+            const f = ((_b = p.fields) != null ? _b : []).find(
+              (x) => x.id === fieldId
+            );
+            if (!f) return;
+            if (!f.bind_id) {
+              f.bind_id = tagId;
+              return;
+            }
+            if (typeof f.bind_id === "string") {
+              if (f.bind_id !== tagId)
+                f.bind_id = [f.bind_id, tagId];
+              return;
+            }
+            if (!f.bind_id.includes(tagId))
+              f.bind_id.push(tagId);
+            return;
+          }
+          throw new Error(
+            `bind: unsupported route ${fromId} \u2192 ${toId}`
+          );
+        }
+        if (kind === "include" || kind === "exclude") {
+          const key = kind === "include" ? "includes" : "excludes";
+          if (isTagId(fromId) && isFieldId(toId)) {
+            const t = ((_c = p.filters) != null ? _c : []).find(
+              (x) => x.id === fromId
+            );
+            if (!t) return;
+            const arr = (_d = t[key]) != null ? _d : t[key] = [];
+            if (!arr.includes(toId)) arr.push(toId);
+            return;
+          }
+          if (isOptionId(fromId) && isFieldId(toId)) {
+            const mapKey = kind === "include" ? "includes_for_options" : "excludes_for_options";
+            const maps = p[mapKey];
+            const next = { ...maps != null ? maps : {} };
+            const arr = (_e = next[fromId]) != null ? _e : [];
+            if (!arr.includes(toId)) arr.push(toId);
+            next[fromId] = arr;
+            p[mapKey] = next;
+            return;
+          }
+          throw new Error(
+            `${kind}: unsupported route ${fromId} \u2192 ${toId}`
+          );
+        }
+        if (kind === "service") {
+          ensureServiceExists(this.opts, fromId);
+          if (toId.startsWith("t:")) {
+            this.exec({
+              name: "connect:service\u2192tag",
+              do: () => this.patchProps((p2) => {
+                var _a2;
+                const t = ((_a2 = p2.filters) != null ? _a2 : []).find(
+                  (x) => x.id === toId
+                );
+                if (t) t.service_id = fromId;
+              }),
+              undo: () => this.api.undo()
+            });
+            return;
+          }
+          if (toId.startsWith("o:")) {
+            this.exec({
+              name: "connect:service\u2192option",
+              do: () => this.patchProps((p2) => {
+                var _a2, _b2;
+                for (const f of (_a2 = p2.fields) != null ? _a2 : []) {
+                  const o = (_b2 = f.options) == null ? void 0 : _b2.find(
+                    (x) => x.id === toId
+                  );
+                  if (o) {
+                    o.service_id = fromId;
+                    return;
+                  }
+                }
+              }),
+              undo: () => this.api.undo()
+            });
+            return;
+          }
+          throw new Error(
+            'service: to must be a tag ("t:*") or option ("o:*")'
+          );
+        }
+        throw new Error(`Unknown connect kind: ${kind}`);
+      }),
+      undo: () => this.api.undo()
+      // snapshot-based undo will restore prior state
+    });
+  }
+  /* ──────────────────────────────────────────────────────────────────────────
+   * DISCONNECT
+   * ────────────────────────────────────────────────────────────────────────── */
+  disconnect(kind, fromId, toId) {
+    this.exec({
+      name: `disconnect:${kind}`,
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (kind === "bind") {
+          if (isTagId(fromId) && isTagId(toId)) {
+            const child = ((_a = p.filters) != null ? _a : []).find(
+              (t) => t.id === toId
+            );
+            if ((child == null ? void 0 : child.bind_id) === fromId) delete child.bind_id;
+            return;
+          }
+          if (isTagId(fromId) && isFieldId(toId) || isFieldId(fromId) && isTagId(toId)) {
+            const fieldId = isFieldId(toId) ? toId : fromId;
+            const tagId = isTagId(fromId) ? fromId : toId;
+            const f = ((_b = p.fields) != null ? _b : []).find(
+              (x) => x.id === fieldId
+            );
+            if (!(f == null ? void 0 : f.bind_id)) return;
+            if (typeof f.bind_id === "string") {
+              if (f.bind_id === tagId) delete f.bind_id;
+              return;
+            }
+            f.bind_id = f.bind_id.filter(
+              (x) => x !== tagId
+            );
+            if (((_c = f.bind_id) == null ? void 0 : _c.length) === 0) delete f.bind_id;
+            return;
+          }
+          throw new Error(
+            `unbind: unsupported route ${fromId} \u2192 ${toId}`
+          );
+        }
+        if (kind === "include" || kind === "exclude") {
+          const key = kind === "include" ? "includes" : "excludes";
+          if (isTagId(fromId) && isFieldId(toId)) {
+            const t = ((_d = p.filters) != null ? _d : []).find(
+              (x) => x.id === fromId
+            );
+            if (!t) return;
+            t[key] = ((_e = t[key]) != null ? _e : []).filter((x) => x !== toId);
+            if (!((_f = t[key]) == null ? void 0 : _f.length)) delete t[key];
+            return;
+          }
+          if (isOptionId(fromId) && isFieldId(toId)) {
+            const mapKey = kind === "include" ? "includes_for_options" : "excludes_for_options";
+            const maps = p[mapKey];
+            if (!maps) return;
+            if (maps[fromId]) {
+              maps[fromId] = ((_g = maps[fromId]) != null ? _g : []).filter(
+                (fid) => fid !== toId
+              );
+              if (!((_h = maps[fromId]) == null ? void 0 : _h.length)) delete maps[fromId];
+            }
+            if (!Object.keys(maps).length)
+              delete p[mapKey];
+            return;
+          }
+          throw new Error(
+            `${kind}: unsupported route ${fromId} \u2192 ${toId}`
+          );
+        }
+        if (kind === "service") {
+          ensureServiceExists(this.opts, fromId);
+          if (toId.startsWith("t:")) {
+            this.exec({
+              name: "disconnect:service\u2192tag",
+              do: () => this.patchProps((p2) => {
+                var _a2;
+                const t = ((_a2 = p2.filters) != null ? _a2 : []).find(
+                  (x) => x.id === toId
+                );
+                if (t) delete t.service_id;
+              }),
+              undo: () => this.api.undo()
+            });
+            return;
+          }
+          if (toId.startsWith("o:")) {
+            this.exec({
+              name: "disconnect:service\u2192option",
+              do: () => this.patchProps((p2) => {
+                var _a2, _b2;
+                for (const f of (_a2 = p2.fields) != null ? _a2 : []) {
+                  const o = (_b2 = f.options) == null ? void 0 : _b2.find(
+                    (x) => x.id === toId
+                  );
+                  if (o) {
+                    delete o.service_id;
+                    return;
+                  }
+                }
+              }),
+              undo: () => this.api.undo()
+            });
+            return;
+          }
+          throw new Error(
+            'service: to must be a tag ("t:*") or option ("o:*")'
+          );
+        }
+        throw new Error(`Unknown disconnect kind: ${kind}`);
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  setConstraint(tagId, flag, value) {
+    let prev;
+    this.exec({
+      name: "setConstraint",
+      do: () => this.patchProps((p) => {
+        var _a, _b;
+        const t = ((_a = p.filters) != null ? _a : []).find((x) => x.id === tagId);
+        if (!t) return;
+        prev = (_b = t.constraints) == null ? void 0 : _b[flag];
+        if (!t.constraints) t.constraints = {};
+        if (value === void 0) delete t.constraints[flag];
+        else t.constraints[flag] = value;
+      }),
+      undo: () => this.patchProps((p) => {
+        var _a;
+        const t = ((_a = p.filters) != null ? _a : []).find((x) => x.id === tagId);
+        if (!t) return;
+        if (!t.constraints) t.constraints = {};
+        if (prev === void 0) delete t.constraints[flag];
+        else t.constraints[flag] = prev;
+      })
+    });
+  }
+  /**
+   * Clear a constraint override by removing the local constraint that conflicts with an ancestor.
+   */
+  clearConstraintOverride(tagId, flag) {
+    let prev;
+    let prevOverride;
+    this.exec({
+      name: "clearConstraintOverride",
+      do: () => this.patchProps((p) => {
+        var _a, _b, _c;
+        const t = ((_a = p.filters) != null ? _a : []).find((x) => x.id === tagId);
+        if (!t) return;
+        prev = (_b = t.constraints) == null ? void 0 : _b[flag];
+        prevOverride = (_c = t.constraints_overrides) == null ? void 0 : _c[flag];
+        if (t.constraints) delete t.constraints[flag];
+        if (t.constraints_overrides)
+          delete t.constraints_overrides[flag];
+      }),
+      undo: () => this.patchProps((p) => {
+        var _a;
+        const t = ((_a = p.filters) != null ? _a : []).find((x) => x.id === tagId);
+        if (!t) return;
+        if (prev !== void 0) {
+          if (!t.constraints) t.constraints = {};
+          t.constraints[flag] = prev;
+        }
+        if (prevOverride !== void 0) {
+          if (!t.constraints_overrides)
+            t.constraints_overrides = {};
+          t.constraints_overrides[flag] = prevOverride;
+        }
+      })
+    });
+  }
+  /**
+   * Clear a constraint from a tag and its descendants.
+   * If a descendant has an override, it assigns that override's value as local.
+   */
+  clearConstraint(tagId, flag) {
+    this.exec({
+      name: "clearConstraint",
+      do: () => this.patchProps((p) => {
+        var _a;
+        const tags = (_a = p.filters) != null ? _a : [];
+        const byId = new Map(tags.map((t) => [t.id, t]));
+        const children = /* @__PURE__ */ new Map();
+        for (const t of tags) {
+          if (t.bind_id) {
+            if (!children.has(t.bind_id))
+              children.set(t.bind_id, []);
+            children.get(t.bind_id).push(t.id);
+          }
+        }
+        const process = (id) => {
+          var _a2, _b, _c;
+          const t = byId.get(id);
+          if (!t) return;
+          const override = (_a2 = t.constraints_overrides) == null ? void 0 : _a2[flag];
+          if (override) {
+            if (!t.constraints) t.constraints = {};
+            t.constraints[flag] = override.from;
+            delete t.constraints_overrides[flag];
+            if (Object.keys((_b = t.constraints_overrides) != null ? _b : {}).length === 0) {
+              delete t.constraints_overrides;
+            }
+          } else {
+            if (t.constraints) {
+              delete t.constraints[flag];
+              if (Object.keys(t.constraints).length === 0) {
+                delete t.constraints;
+              }
+            }
+          }
+          for (const childId of (_c = children.get(id)) != null ? _c : []) {
+            process(childId);
+          }
+        };
+        process(tagId);
+      }),
+      undo: () => this.api.undo()
+    });
+  }
+  /* ───────────────────── Internals ───────────────────── */
+  replaceProps(next) {
+    const norm = normalise(next, {
+      constraints: this.builder.getConstraints().map((item) => item.label),
+      defaultPricingRole: "base"
+    });
+    this.builder.load(norm);
+    this.api.refreshGraph();
+  }
+  patchProps(mut) {
+    const cur = (0, import_lodash_es2.cloneDeep)(this.builder.getProps());
+    mut(cur);
+    this.replaceProps(cur);
+  }
+  afterMutation(command, _before) {
+    if (this.txnDepth > 0) return;
+    this.pushHistory(this.makeSnapshot(command));
+    this.emit("editor:command", { name: command });
+    if (this.opts.validateAfterEach)
+      this.emit("editor:change", {
+        props: this.builder.getProps(),
+        reason: "validate",
+        command
+      });
+    else
+      this.emit("editor:change", {
+        props: this.builder.getProps(),
+        reason: "mutation",
+        command
+      });
+  }
+  commit(label) {
+    const snap = this.makeSnapshot(label);
+    this.pushHistory(snap);
+    this.emit("editor:change", {
+      props: snap.props,
+      reason: "transaction",
+      command: this.txnLabel
+    });
+  }
+  makeSnapshot(_why) {
+    const props = (0, import_lodash_es2.cloneDeep)(this.builder.getProps());
+    const canvas = this.api.snapshot();
+    return {
+      props,
+      layout: {
+        canvas
+      }
+    };
+  }
+  loadSnapshot(s, reason) {
+    this.builder.load((0, import_lodash_es2.cloneDeep)(s.props));
+    const layout = s.layout;
+    const canvas = layout == null ? void 0 : layout.canvas;
+    if (canvas) {
+      if (canvas.positions) this.api.setPositions(canvas.positions);
+      if (canvas.viewport) this.api.setViewport(canvas.viewport);
+      if (canvas.selection)
+        this.api.select(
+          Array.isArray(canvas.selection) ? canvas.selection : Array.from(canvas.selection)
+        );
+    } else {
+      this.api.refreshGraph();
+    }
+    this.emit("editor:change", { props: this.builder.getProps(), reason });
+  }
+  pushHistory(snap) {
+    if (this.index < this.history.length - 1) {
+      this.history = this.history.slice(0, this.index + 1);
+    }
+    this.history.push(snap);
+    const over = this.history.length - this.opts.historyLimit;
+    if (over > 0) {
+      this.history.splice(0, over);
+      this.index = this.history.length - 1;
+    } else {
+      this.index = this.history.length - 1;
+    }
+  }
+  // IDs like "t:1", "f:2", "o:3" — must be unique across tags, fields, options.
+  genId(prefix) {
+    var _a, _b, _c;
+    const props = this.builder.getProps();
+    const taken = /* @__PURE__ */ new Set([
+      ...((_a = props.filters) != null ? _a : []).map((t) => t.id),
+      ...((_b = props.fields) != null ? _b : []).map((f) => f.id),
+      ...((_c = props.fields) != null ? _c : []).flatMap(
+        (f) => {
+          var _a2, _b2;
+          return (_b2 = (_a2 = f.options) == null ? void 0 : _a2.map((o) => o.id)) != null ? _b2 : [];
+        }
+      )
+    ]);
+    for (let i = 1; i < 1e4; i++) {
+      const id = `${prefix}:${i}`;
+      if (!taken.has(id)) return id;
+    }
+    throw new Error("Unable to generate id");
+  }
+  emit(event, payload) {
+    this.api.emit(event, payload);
+  }
+  /**
+   * Suggest/filter candidate services against the current visible-group
+   * (single tag) context.
+   *
+   * - Excludes services already used in this group.
+   * - Applies capability presence, tag constraints, rate policy, and compiled policies.
+   *
+   * @param candidates    service ids to evaluate
+   * @param ctx
+   * @param ctx.tagId     active visible-group tag id
+   * @param ctx.usedServiceIds  services already selected for this visible group (first is treated as "primary" for rate policy)
+   * @param ctx.effectiveConstraints  effective constraints for the active tag (dripfeed/refill/cancel)
+   * @param ctx.policies  raw JSON policies (will be compiled via compilePolicies)
+   * @param ctx.fallback  fallback/rate settings (defaults applied if omitted)
+   */
+  filterServicesForVisibleGroup(candidates, ctx) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const svcMap = (_e = (_d = (_a = this.opts) == null ? void 0 : _a.serviceMap) != null ? _d : (_c = (_b = this.builder).getServiceMap) == null ? void 0 : _c.call(_b)) != null ? _e : {};
+    const usedSet = new Set(ctx.usedServiceIds.map(String));
+    const primary = ctx.usedServiceIds[0];
+    const fb = {
+      requireConstraintFit: true,
+      ratePolicy: { kind: "lte_primary" },
+      selectionStrategy: "priority",
+      mode: "strict",
+      ...(_f = ctx.fallback) != null ? _f : {}
+    };
+    const evaluatePoliciesRaw = (raw, serviceIds, tagId) => {
+      const { policies } = compilePolicies(raw);
+      return evaluateServicePolicies(policies, serviceIds, svcMap, tagId);
+    };
+    const out = [];
+    for (const id of candidates) {
+      if (usedSet.has(String(id))) continue;
+      const cap = svcMap[Number(id)];
+      if (!cap) {
+        out.push({
+          id,
+          ok: false,
+          fitsConstraints: false,
+          passesRate: false,
+          passesPolicies: false,
+          reasons: ["missing_capability"]
+        });
+        continue;
+      }
+      const fitsConstraints = constraintFitOk(
+        svcMap,
+        cap.id,
+        (_g = ctx.effectiveConstraints) != null ? _g : {}
+      );
+      const passesRate = primary == null ? true : rateOk(svcMap, id, primary, fb);
+      const polRes = evaluatePoliciesRaw(
+        (_h = ctx.policies) != null ? _h : [],
+        [...ctx.usedServiceIds, id],
+        ctx.tagId
+      );
+      const passesPolicies = polRes.ok;
+      const reasons = [];
+      if (!fitsConstraints) reasons.push("constraint_mismatch");
+      if (!passesRate) reasons.push("rate_policy");
+      if (!passesPolicies) reasons.push("policy_error");
+      out.push({
+        id,
+        ok: fitsConstraints && passesRate && passesPolicies,
+        fitsConstraints,
+        passesRate,
+        passesPolicies,
+        policyErrors: polRes.errors.length ? polRes.errors : void 0,
+        policyWarnings: polRes.warnings.length ? polRes.warnings : void 0,
+        reasons,
+        cap,
+        rate: toFiniteNumber(cap.rate)
+      });
+    }
+    return out;
+  }
+};
+function nextCopyLabel(old) {
+  const m = old.match(/^(.*?)(?:\s*\(copy(?:\s+(\d+))?\))$/i);
+  if (!m) return `${old} (copy)`;
+  const stem = m[1].trim();
+  const n = m[2] ? parseInt(m[2], 10) + 1 : 2;
+  return `${stem} (copy ${n})`;
+}
+function nextCopyName(old) {
+  if (!old) return void 0;
+  const m = old.match(/^(.*?)(_copy(\d+)?)$/i);
+  if (!m) return `${old}_copy`;
+  const stem = m[1];
+  const n = m[3] ? parseInt(m[3], 10) + 1 : 2;
+  return `${stem}_copy${n}`;
+}
+function defaultOptionIdStrategy(old) {
+  return nextCopyId(old);
+}
+function nextCopyId(old) {
+  const m = old.match(/^(.*?)(?:_copy(\d+)?)$/i);
+  if (!m) return `${old}_copy`;
+  const stem = m[1];
+  const n = m[2] ? parseInt(m[2], 10) + 1 : 2;
+  return `${stem}_copy${n}`;
+}
+function bumpSuffix(old) {
+  const m = old.match(/^(.*?)(\d+)$/);
+  if (!m) return `${old}2`;
+  const stem = m[1];
+  return `${stem}${parseInt(m[2], 10) + 1}`;
+}
+function normalizeQuantityRule(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const v = input;
+  const vb = v.valueBy;
+  if (vb !== "value" && vb !== "length" && vb !== "eval") return void 0;
+  const out = { valueBy: vb };
+  if (vb === "eval" && typeof v.code === "string" && v.code.trim()) {
+    out.code = v.code;
+  }
+  return out;
+}
+function evaluateServicePolicies(rules, svcIds, svcMap, tagId) {
+  var _a, _b, _c;
+  const errors = [];
+  const warnings = [];
+  if (!rules || !rules.length) return { ok: true, errors, warnings };
+  const relevant = rules.filter(
+    (r) => r.subject === "services" && (r.scope === "visible_group" || r.scope === "global")
+  );
+  for (const r of relevant) {
+    const ids = svcIds.filter(
+      (id) => matchesRuleFilter(svcMap[Number(id)], r, tagId)
+    );
+    const projection = r.projection || "service.id";
+    const values = ids.map(
+      (id) => policyProjectValue(svcMap[Number(id)], projection)
+    );
+    let ok = true;
+    switch (r.op) {
+      case "all_equal":
+        ok = values.length <= 1 || values.every((v) => v === values[0]);
+        break;
+      case "unique": {
+        const uniq = new Set(values.map((v) => String(v)));
+        ok = uniq.size === values.length;
+        break;
+      }
+      case "no_mix": {
+        const uniq = new Set(values.map((v) => String(v)));
+        ok = uniq.size <= 1;
+        break;
+      }
+      case "all_true":
+        ok = values.every((v) => !!v);
+        break;
+      case "any_true":
+        ok = values.some((v) => !!v);
+        break;
+      case "max_count": {
+        const n = typeof r.value === "number" ? r.value : NaN;
+        ok = Number.isFinite(n) ? values.length <= n : true;
+        break;
+      }
+      case "min_count": {
+        const n = typeof r.value === "number" ? r.value : NaN;
+        ok = Number.isFinite(n) ? values.length >= n : true;
+        break;
+      }
+      default:
+        ok = true;
+    }
+    if (!ok) {
+      if (((_a = r.severity) != null ? _a : "error") === "error")
+        errors.push((_b = r.id) != null ? _b : "policy_error");
+      else warnings.push((_c = r.id) != null ? _c : "policy_warning");
+    }
+  }
+  return { ok: errors.length === 0, errors, warnings };
+}
+function policyProjectValue(cap, projection) {
+  if (!cap) return void 0;
+  const key = projection.startsWith("service.") ? projection.slice(8) : projection;
+  return cap[key];
+}
+function matchesRuleFilter(cap, rule, tagId) {
+  if (!cap) return false;
+  const f = rule.filter;
+  if (!f) return true;
+  if (f.tag_id && !toStrSet(f.tag_id).has(String(tagId))) return false;
+  return true;
+}
+function toStrSet(v) {
+  const arr = Array.isArray(v) ? v : [v];
+  const s = /* @__PURE__ */ new Set();
+  for (const x of arr) s.add(String(x));
+  return s;
+}
+
+// src/react/canvas/selection.ts
+var isTagId2 = (id) => typeof id === "string" && id.startsWith("t:");
+var isOptionId2 = (id) => typeof id === "string" && id.startsWith("o:");
+var Selection = class {
+  constructor(builder, opts) {
+    this.builder = builder;
+    this.opts = opts;
+    this.set = /* @__PURE__ */ new Set();
+    this.onChangeFns = [];
+  }
+  // ── Public mutators ──────────────────────────────────────────────────────
+  replace(id) {
+    if (!id) return this.clear();
+    this.set.clear();
+    this.set.add(id);
+    this.primaryId = id;
+    this.updateCurrentTagFrom(id);
+    this.emit();
+  }
+  add(id) {
+    this.set.add(id);
+    this.primaryId = id;
+    this.updateCurrentTagFrom(id);
+    this.emit();
+  }
+  remove(id) {
+    if (!this.set.delete(id)) return;
+    if (this.primaryId === id) {
+      this.primaryId = this.set.values().next().value;
+      if (this.primaryId) this.updateCurrentTagFrom(this.primaryId);
+    }
+    this.emit();
+  }
+  toggle(id) {
+    if (this.set.has(id)) this.remove(id);
+    else this.add(id);
+  }
+  many(ids, primary) {
+    this.set = new Set(ids);
+    this.primaryId = primary != null ? primary : this.set.values().next().value;
+    if (this.primaryId) this.updateCurrentTagFrom(this.primaryId);
+    this.emit();
+  }
+  clear() {
+    if (!this.set.size && !this.primaryId) return;
+    this.set.clear();
+    this.primaryId = void 0;
+    this.emit();
+  }
+  // ── Read APIs ────────────────────────────────────────────────────────────
+  all() {
+    return this.set;
+  }
+  has(id) {
+    return this.set.has(id);
+  }
+  primary() {
+    return this.primaryId;
+  }
+  currentTag() {
+    return this.currentTagId;
+  }
+  onChange(fn) {
+    this.onChangeFns.push(fn);
+    return () => {
+      const i = this.onChangeFns.indexOf(fn);
+      if (i >= 0) this.onChangeFns.splice(i, 1);
+    };
+  }
+  // ── Main: visible group snapshot (env-aware) ─────────────────────────────
+  visibleGroup() {
+    var _a;
+    const props = this.builder.getProps();
+    if (((_a = this.opts.env) != null ? _a : "client") === "workspace") {
+      const tagIds = Array.from(this.set).filter(isTagId2);
+      if (tagIds.length > 1) {
+        return { kind: "multi", groups: Array.from(this.set) };
+      }
+    }
+    const tagId = this.resolveTagContextId(props);
+    if (!tagId)
+      return { kind: "single", group: { fields: [], fieldIds: [] } };
+    const group = this.computeGroupForTag(props, tagId);
+    return { kind: "single", group };
+  }
+  // ── Internals ────────────────────────────────────────────────────────────
+  emit() {
+    const payload = {
+      ids: Array.from(this.set),
+      primary: this.primaryId
+    };
+    for (const fn of this.onChangeFns) fn(payload);
+  }
+  updateCurrentTagFrom(id) {
+    var _a, _b;
+    const props = this.builder.getProps();
+    const tags = (_a = props.filters) != null ? _a : [];
+    const fields = (_b = props.fields) != null ? _b : [];
+    if (tags.some((t) => t.id === id)) {
+      this.currentTagId = id;
+      return;
+    }
+    const f = fields.find((x) => x.id === id);
+    if (f == null ? void 0 : f.bind_id) {
+      this.currentTagId = Array.isArray(f.bind_id) ? f.bind_id[0] : f.bind_id;
+      return;
+    }
+    if (isOptionId2(id)) {
+      const host = fields.find(
+        (x) => {
+          var _a2;
+          return ((_a2 = x.options) != null ? _a2 : []).some((o) => o.id === id);
+        }
+      );
+      if (host == null ? void 0 : host.bind_id) {
+        this.currentTagId = Array.isArray(host.bind_id) ? host.bind_id[0] : host.bind_id;
+        return;
+      }
+    }
+    if (id.includes("::")) {
+      const [fid] = id.split("::");
+      const host = fields.find((x) => x.id === fid);
+      if (host == null ? void 0 : host.bind_id) {
+        this.currentTagId = Array.isArray(host.bind_id) ? host.bind_id[0] : host.bind_id;
+        return;
+      }
+    }
+  }
+  resolveTagContextId(props) {
+    var _a;
+    if (this.currentTagId) return this.currentTagId;
+    for (const id of this.set) if (isTagId2(id)) return id;
+    const fields = (_a = props.fields) != null ? _a : [];
+    for (const id of this.set) {
+      const f = fields.find((x) => x.id === id);
+      if (f == null ? void 0 : f.bind_id)
+        return Array.isArray(f.bind_id) ? f.bind_id[0] : f.bind_id;
+    }
+    for (const id of this.set) {
+      if (isOptionId2(id)) {
+        const host = fields.find(
+          (x) => {
+            var _a2;
+            return ((_a2 = x.options) != null ? _a2 : []).some((o) => o.id === id);
+          }
+        );
+        if (host == null ? void 0 : host.bind_id)
+          return Array.isArray(host.bind_id) ? host.bind_id[0] : host.bind_id;
+      }
+      if (id.includes("::")) {
+        const [fid] = id.split("::");
+        const host = fields.find((x) => x.id === fid);
+        if (host == null ? void 0 : host.bind_id)
+          return Array.isArray(host.bind_id) ? host.bind_id[0] : host.bind_id;
+      }
+    }
+    return this.opts.rootTagId;
+  }
+  selectedButtonTriggerIds(props) {
+    var _a;
+    const fields = (_a = props.fields) != null ? _a : [];
+    const fieldById = new Map(fields.map((f) => [f.id, f]));
+    const out = [];
+    for (const selId of this.set) {
+      if (selId.startsWith("o:")) {
+        out.push(selId);
+        continue;
+      }
+      const f = fieldById.get(selId);
+      if ((f == null ? void 0 : f.button) === true) out.push(selId);
+    }
+    return out;
+  }
+  computeGroupForTag(props, tagId) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    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);
+    const selectedTriggerIds = this.selectedButtonTriggerIds(props);
+    const fieldIds = this.builder.visibleFields(tagId, selectedTriggerIds);
+    const fieldById = new Map(fields.map((f) => [f.id, f]));
+    const visible = fieldIds.map((id) => fieldById.get(id)).filter(Boolean);
+    const parentTags = [];
+    let cur = tag == null ? void 0 : tag.bind_id;
+    const guard = /* @__PURE__ */ new Set();
+    while (cur && !guard.has(cur)) {
+      const t = tagById.get(cur);
+      if (!t) break;
+      parentTags.push(t);
+      guard.add(cur);
+      cur = t.bind_id;
+    }
+    const childrenTags = tags.filter((t) => t.bind_id === tagId);
+    const services = [];
+    const resolve = this.opts.resolveService;
+    let baseAddedFromTag = false;
+    if ((tag == null ? void 0 : tag.service_id) != null) {
+      services.push(
+        (_c = resolve == null ? void 0 : resolve(tag.service_id)) != null ? _c : { id: tag.service_id }
+      );
+      baseAddedFromTag = true;
+    }
+    let baseOverridden = false;
+    for (const selId of this.set) {
+      const opt = this.findOptionById(fields, selId);
+      if ((opt == null ? void 0 : opt.service_id) != null) {
+        const role = (_d = opt.pricing_role) != null ? _d : "base";
+        const cap = (_e = resolve == null ? void 0 : resolve(opt.service_id)) != null ? _e : { id: opt.service_id };
+        baseOverridden = this.addServiceByRole(
+          services,
+          cap,
+          role,
+          baseAddedFromTag,
+          baseOverridden
+        );
+        continue;
+      }
+      const f = fieldById.get(selId);
+      if ((f == null ? void 0 : f.button) === true && f.service_id != null) {
+        const role = (_f = f.pricing_role) != null ? _f : "base";
+        const cap = (_g = resolve == null ? void 0 : resolve(f.service_id)) != null ? _g : { id: f.service_id };
+        baseOverridden = this.addServiceByRole(
+          services,
+          cap,
+          role,
+          baseAddedFromTag,
+          baseOverridden
+        );
+      }
+    }
+    return {
+      tagId,
+      tag,
+      fields: visible,
+      fieldIds,
+      parentTags,
+      childrenTags,
+      services
+    };
+  }
+  addServiceByRole(services, cap, role, baseAddedFromTag, baseOverridden) {
+    if (role === "base") {
+      if (!baseOverridden) {
+        if (baseAddedFromTag && services.length > 0) {
+          services[0] = cap;
+        } else {
+          services.unshift(cap);
+        }
+        return true;
+      } else {
+        services.push(cap);
+      }
+    } else {
+      services.push(cap);
+    }
+    return baseOverridden;
+  }
+  findOptionById(fields, selId) {
+    var _a, _b;
+    if (isOptionId2(selId)) {
+      for (const f of fields) {
+        const o = (_a = f.options) == null ? void 0 : _a.find((x) => x.id === selId);
+        if (o) return o;
+      }
+    }
+    if (selId.includes("::")) {
+      const [fid, oid] = selId.split("::");
+      const f = fields.find((x) => x.id === fid);
+      const o = (_b = f == null ? void 0 : f.options) == null ? void 0 : _b.find((x) => x.id === oid || x.id === selId);
+      if (o) return o;
+    }
+    return void 0;
+  }
+};
+
+// src/react/canvas/api.ts
+var CanvasAPI = class {
+  constructor(builder, opts = {}) {
+    this.bus = new EventBus();
+    /* ─── Events ─────────────────────────────────────────────── */
+    this.on = this.bus.on.bind(this.bus);
+    this.once = this.bus.once.bind(this.bus);
+    this.edgeRel = "bind";
+    /* ─── Option-node visibility (per field) ───────────────────────────────── */
+    /** Internal mirror of which fields should show their options as nodes. */
+    this.shownOptionFields = /* @__PURE__ */ new Set();
+    var _a, _b, _c;
+    this.builder = builder;
+    this.autoEmit = (_a = opts.autoEmitState) != null ? _a : true;
+    this.selection = new Selection(builder, {
+      env: "workspace",
+      rootTagId: "t:root"
+    });
+    const graph = builder.tree();
+    this.state = {
+      graph,
+      positions: {},
+      selection: /* @__PURE__ */ new Set(),
+      highlighted: /* @__PURE__ */ new Set(),
+      viewport: { x: 0, y: 0, zoom: 1, ...opts.initialViewport },
+      version: 1
+    };
+    this.selection.onChange(({ ids }) => {
+      this.state.selection = new Set(ids);
+      this.bump();
+      this.bus.emit("selection:change", { ids });
+      if (this.autoEmit) this.bus.emit("state:change", this.snapshot());
+    });
+    const scopeProvider = (_b = opts.getScope) != null ? _b : (() => {
+      const anyOpts = opts;
+      if (!anyOpts.workspaceId || !anyOpts.actorId || !anyOpts.branchId) {
+        return void 0;
+      }
+      return {
+        workspaceId: anyOpts.workspaceId,
+        actorId: anyOpts.actorId,
+        branchId: anyOpts.branchId
+      };
+    });
+    this.comments = new CommentsAPI(this.bus, {
+      backend: (_c = opts.backend) == null ? void 0 : _c.comments,
+      getScope: scopeProvider
+    });
+    this.editor = new Editor(builder, this, {
+      serviceMap: builder.getServiceMap(),
+      serviceExists: (id) => builder.getServiceMap().hasOwnProperty(id),
+      ...opts
+    });
+    if (this.autoEmit) this.bus.emit("state:change", this.snapshot());
+  }
+  emit(event, payload) {
+    this.bus.emit(event, payload);
+  }
+  /* ─── State accessors ───────────────────────────────────── */
+  snapshot() {
+    return {
+      ...this.state,
+      selection: new Set(this.state.selection),
+      highlighted: new Set(this.state.highlighted),
+      graph: {
+        nodes: [...this.state.graph.nodes],
+        edges: [...this.state.graph.edges]
+      },
+      positions: { ...this.state.positions }
+    };
+  }
+  getGraph() {
+    return this.state.graph;
+  }
+  getSelection() {
+    return Array.from(this.state.selection);
+  }
+  getViewport() {
+    return { ...this.state.viewport };
+  }
+  /* ─── Graph lifecycle ───────────────────────────────────── */
+  refreshGraph() {
+    this.state.graph = this.builder.tree();
+    this.bump();
+    this.bus.emit("graph:update", this.state.graph);
+  }
+  setPositions(pos) {
+    this.state.positions = { ...this.state.positions, ...pos };
+    this.bump();
+  }
+  setPosition(id, x, y) {
+    this.state.positions[id] = { x, y };
+    this.bump();
+  }
+  /* ─── Selection ─────────────────────────────────────────── */
+  select(ids) {
+    this.selection.many(ids);
+  }
+  addToSelection(ids) {
+    const next = new Set(this.selection.all());
+    let primary;
+    for (const id of ids) {
+      next.add(id);
+      primary = id;
+    }
+    this.selection.many(next, primary);
+  }
+  toggleSelection(id) {
+    this.selection.toggle(id);
+  }
+  clearSelection() {
+    this.selection.clear();
+  }
+  selectComments(threadId) {
+    this.bus.emit("comment:select", { threadId });
+  }
+  /* ─── Highlight / Hover ─────────────────────────────────── */
+  setHighlighted(ids) {
+    this.state.highlighted = new Set(ids);
+    this.bump();
+  }
+  setHover(id) {
+    this.state.hoverId = id;
+    this.bump();
+    this.bus.emit("hover:change", { id });
+  }
+  /* ─── Viewport ──────────────────────────────────────────── */
+  setViewport(v) {
+    this.state.viewport = { ...this.state.viewport, ...v };
+    this.bump();
+    this.bus.emit("viewport:change", this.getViewport());
+  }
+  /* ─── Wiring draft (for bind/include/exclude UX) ────────── */
+  startWire(from, kind) {
+    this.state.draftWire = { from, kind };
+    this.bump();
+    this.bus.emit("wire:preview", { from, kind });
+  }
+  previewWire(to) {
+    const dw = this.state.draftWire;
+    if (!dw) return;
+    this.bus.emit("wire:preview", { from: dw.from, to, kind: dw.kind });
+  }
+  commitWire(to) {
+    const dw = this.state.draftWire;
+    if (!dw) return;
+    this.bus.emit("wire:commit", { from: dw.from, to, kind: dw.kind });
+    this.state.draftWire = void 0;
+    this.bump();
+  }
+  cancelWire() {
+    const dw = this.state.draftWire;
+    if (!dw) return;
+    this.bus.emit("wire:cancel", { from: dw.from });
+    this.state.draftWire = void 0;
+    this.bump();
+  }
+  /* ─── Utilities ─────────────────────────────────────────── */
+  bump() {
+    this.state.version++;
+    if (this.autoEmit) this.bus.emit("state:change", this.snapshot());
+  }
+  dispose() {
+    this.bus.clear();
+  }
+  undo() {
+    this.builder.undo();
+    this.refreshGraph();
+  }
+  getEdgeRel() {
+    return this.edgeRel;
+  }
+  setEdgeRel(rel) {
+    if (this.edgeRel === rel) return;
+    this.edgeRel = rel;
+    this.bus.emit("edge:change", rel);
+  }
+  /** Return the field ids whose options are currently set to be visible as nodes. */
+  getShownOptionFields() {
+    return Array.from(this.shownOptionFields);
+  }
+  /** True if this field’s options are shown as nodes. */
+  isFieldOptionsShown(fieldId) {
+    return this.shownOptionFields.has(String(fieldId));
+  }
+  /**
+   * Set visibility of option nodes for a field, then rebuild the graph.
+   * When shown = true, the Builder will emit option nodes for this field.
+   */
+  setFieldOptionsShown(fieldId, shown) {
+    const id = String(fieldId);
+    const before = this.shownOptionFields.has(id);
+    if (shown && !before) this.shownOptionFields.add(id);
+    else if (!shown && before) this.shownOptionFields.delete(id);
+    else return;
+    this.builder.setOptions({
+      showOptionNodes: new Set(this.shownOptionFields)
+    });
+    this.refreshGraph();
+  }
+  /** Toggle option-node visibility for a field. Returns the new visibility. */
+  toggleFieldOptions(fieldId) {
+    const next = !this.isFieldOptionsShown(fieldId);
+    this.setFieldOptionsShown(fieldId, next);
+    return next;
+  }
+  /**
+   * Replace the whole set of fields whose options are visible as nodes.
+   * Useful for restoring a saved UI state.
+   */
+  setShownOptionFields(ids) {
+    const next = new Set(Array.from(ids, String));
+    if (next.size === this.shownOptionFields.size && Array.from(next).every((id) => this.shownOptionFields.has(id))) {
+      return;
+    }
+    this.shownOptionFields = next;
+    this.builder.setOptions({
+      showOptionNodes: new Set(this.shownOptionFields)
+    });
+    this.refreshGraph();
+  }
+  getConstraints() {
+    return this.builder.getConstraints();
+  }
+  getServiceProps() {
+    return this.builder.getProps();
+  }
+};
+
+// src/react/inputs/form-context.tsx
+var import_react2 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var FormCtx = (0, import_react2.createContext)(null);
+function FormProvider({
+  initial,
+  children
+}) {
+  var _a, _b;
+  const [values, setValues] = (0, import_react2.useState)(
+    (_a = initial == null ? void 0 : initial.values) != null ? _a : {}
+  );
+  const [selections, setSelections] = (0, import_react2.useState)(
+    (_b = initial == null ? void 0 : initial.selections) != null ? _b : {}
+  );
+  const subsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const publish = (0, import_react2.useCallback)(() => {
+    for (const fn of Array.from(subsRef.current)) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  }, []);
+  const api = (0, import_react2.useMemo)(
+    () => ({
+      get: (fieldId) => values[fieldId],
+      set: (fieldId, value) => {
+        setValues((prev) => {
+          if (prev[fieldId] === value) return prev;
+          const next = { ...prev, [fieldId]: value };
+          return next;
+        });
+        publish();
+      },
+      getSelections: (fieldId) => {
+        var _a2;
+        return (_a2 = selections[fieldId]) != null ? _a2 : [];
+      },
+      setSelections: (fieldId, optionIds) => {
+        setSelections((prev) => {
+          const next = {
+            ...prev,
+            [fieldId]: Array.from(new Set(optionIds))
+          };
+          return next;
+        });
+        publish();
+      },
+      toggleSelection: (fieldId, optionId) => {
+        setSelections((prev) => {
+          var _a2;
+          const cur = new Set((_a2 = prev[fieldId]) != null ? _a2 : []);
+          if (cur.has(optionId)) cur.delete(optionId);
+          else cur.add(optionId);
+          return { ...prev, [fieldId]: Array.from(cur) };
+        });
+        publish();
+      },
+      snapshot: () => ({
+        values: { ...values },
+        selections: { ...selections }
+      }),
+      subscribe: (fn) => {
+        subsRef.current.add(fn);
+        return () => subsRef.current.delete(fn);
+      }
+    }),
+    [publish, selections, values]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormCtx.Provider, { value: api, children });
+}
+function useFormApi() {
+  const ctx = (0, import_react2.useContext)(FormCtx);
+  if (!ctx) throw new Error("useFormApi must be used within <FormProvider>");
+  return ctx;
+}
+function useOptionalFormApi() {
+  return (0, import_react2.useContext)(FormCtx);
+}
+function useFormField(fieldId) {
+  const api = useFormApi();
+  const value = api.get(fieldId);
+  const set = (v) => api.set(fieldId, v);
+  return { value, set };
+}
+function useFormSelections(fieldId) {
+  const api = useFormApi();
+  return {
+    selected: api.getSelections(fieldId),
+    set: (arr) => api.setSelections(fieldId, arr),
+    toggle: (oid) => api.toggleSelection(fieldId, oid)
+  };
+}
+
+// src/react/inputs/registry.ts
+function createInputRegistry() {
+  const store = /* @__PURE__ */ new Map();
+  const get = (kind, variant) => {
+    var _a;
+    const vm = store.get(kind);
+    if (!vm) return void 0;
+    const v = variant != null ? variant : "default";
+    return (_a = vm.get(v)) != null ? _a : vm.get("default");
+  };
+  const register = (kind, descriptor, variant) => {
+    let vm = store.get(kind);
+    if (!vm) {
+      vm = /* @__PURE__ */ new Map();
+      store.set(kind, vm);
+    }
+    vm.set(variant != null ? variant : "default", descriptor);
+  };
+  const unregister = (kind, variant) => {
+    const vm = store.get(kind);
+    if (!vm) return;
+    const key = variant != null ? variant : "default";
+    vm.delete(key);
+    if (vm.size === 0) store.delete(kind);
+  };
+  const registerMany = (entries) => {
+    for (const e of entries) register(e.kind, e.descriptor, e.variant);
+  };
+  return { get, register, unregister, registerMany, _store: store };
+}
+function resolveInputDescriptor(registry, kind, variant) {
+  return registry.get(kind, variant);
+}
+
+// src/react/inputs/provider.tsx
+var import_react3 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var Ctx = (0, import_react3.createContext)(null);
+function Provider({
+  children,
+  initialRegistry
+}) {
+  const registry = (0, import_react3.useMemo)(
+    () => initialRegistry != null ? initialRegistry : createInputRegistry(),
+    [initialRegistry]
+  );
+  const value = (0, import_react3.useMemo)(
+    () => ({
+      registry,
+      register: registry.register,
+      unregister: registry.unregister,
+      registerMany: registry.registerMany
+    }),
+    [registry]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Ctx.Provider, { value, children });
+}
+function useInputs() {
+  const v = (0, import_react3.useContext)(Ctx);
+  if (!v) throw new Error("useInputs() must be used within <InputsProvider>");
+  return v;
+}
+
+// src/react/inputs/wrapper.tsx
+var import_react5 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function toKind(field) {
+  var _a;
+  if (field.type === "custom") {
+    const comp = ((_a = field.component) != null ? _a : "").trim();
+    return `custom:${comp}`;
+  }
+  return field.type;
+}
+function toVariant(field) {
+  var _a;
+  const v = (_a = field.meta) == null ? void 0 : _a.variant;
+  return typeof v === "string" && v.trim() ? v : void 0;
+}
+function Wrapper({
+  field,
+  disabled,
+  extraProps
+}) {
+  var _a, _b, _c;
+  const { registry } = useInputs();
+  const form = useOptionalFormApi();
+  const kind = toKind(field);
+  const variant = toVariant(field);
+  const descriptor = (0, import_react5.useMemo)(
+    () => resolveInputDescriptor(registry, kind, variant),
+    [kind, registry, variant]
+  );
+  if (!descriptor) {
+    console.warn("[InputWrapper] No descriptor for", {
+      kind,
+      variant,
+      field
+    });
+    return null;
+  }
+  const { Component, adapter, defaultProps } = descriptor;
+  const valueProp = (_a = adapter == null ? void 0 : adapter.valueProp) != null ? _a : "value";
+  const changeProp = (_b = adapter == null ? void 0 : adapter.changeProp) != null ? _b : "onChange";
+  const isOptionBased = Array.isArray(field.options) && field.options.length > 0;
+  const multi = !!(isOptionBased && isMultiField(field));
+  const isButton = field.button === true || isOptionBased;
+  const optionById = (0, import_react5.useMemo)(() => {
+    var _a2;
+    if (!isOptionBased) return /* @__PURE__ */ new Map();
+    return new Map(((_a2 = field.options) != null ? _a2 : []).map((o) => [o.id, o]));
+  }, [isOptionBased, field.options]);
+  const enrich = (bv) => {
+    var _a2, _b2, _c2;
+    if (isOptionBased) {
+      const opt = optionById.get(bv.id);
+      if (opt) {
+        const role2 = (_a2 = opt.pricing_role) != null ? _a2 : "base";
+        const sid2 = opt.service_id;
+        const meta2 = (_b2 = opt.meta) != null ? _b2 : field.meta;
+        return {
+          ...bv,
+          pricing_role: role2,
+          service_id: role2 === "utility" ? void 0 : sid2,
+          ...meta2 ? { meta: meta2 } : {}
+        };
+      }
+      return bv;
+    }
+    const role = (_c2 = field.pricing_role) != null ? _c2 : "base";
+    const sid = field.service_id;
+    const meta = field.meta;
+    return {
+      ...bv,
+      pricing_role: role,
+      service_id: role === "utility" ? void 0 : sid,
+      ...meta ? { meta } : {}
+    };
+  };
+  function normalizeToButtonValues(input) {
+    const coerceOne = (v) => {
+      if (v && typeof v === "object" && "id" in v) {
+        const id = String(v.id);
+        const valueRaw = v.value;
+        const value = typeof valueRaw === "number" || typeof valueRaw === "string" ? valueRaw : 1;
+        return enrich({ id, value });
+      }
+      if (typeof v === "string" || typeof v === "number") {
+        return enrich({ id: String(v), value: 1 });
+      }
+      return null;
+    };
+    if (Array.isArray(input)) {
+      const arr = [];
+      for (const x of input) {
+        const one2 = coerceOne(x);
+        if (one2) arr.push(one2);
+      }
+      return arr;
+    }
+    const one = coerceOne(input);
+    return one ? [one] : [];
+  }
+  let current = void 0;
+  let onChange = void 0;
+  if (form) {
+    if (isButton) {
+      if (isOptionBased) {
+        const selIds = form.getSelections(field.id);
+        current = multi ? selIds : (_c = selIds[0]) != null ? _c : null;
+        onChange = (next) => {
+          var _a2;
+          const normalized = (adapter == null ? void 0 : adapter.getValue) ? adapter.getValue(next, current) : next;
+          const bvs = normalizeToButtonValues(normalized);
+          const ids = bvs.map((b) => b.id);
+          form.setSelections(field.id, Array.from(new Set(ids)));
+          const values = multi ? bvs : (_a2 = bvs[0]) != null ? _a2 : null;
+          form.set(field.id, values);
+        };
+      } else {
+        const val = form.get(field.id);
+        current = val;
+        onChange = (next) => {
+          const normalized = (adapter == null ? void 0 : adapter.getValue) ? adapter.getValue(next, current) : next;
+          const bvs = normalizeToButtonValues(normalized);
+          const first = bvs[0];
+          const active = first && (typeof first.value === "number" ? first.value !== 0 : String(first.value).length > 0);
+          if (active) {
+            form.setSelections(field.id, [field.id]);
+            form.set(field.id, first.value);
+          } else {
+            form.setSelections(field.id, []);
+            form.set(field.id, null);
+          }
+        };
+      }
+    } else {
+      current = form.get(field.id);
+      onChange = (next) => {
+        const normalized = (adapter == null ? void 0 : adapter.getValue) ? adapter.getValue(next, current) : next;
+        form.set(field.id, normalized);
+      };
+    }
+  }
+  const hostProps = {
+    id: field.id,
+    field,
+    disabled: !!disabled,
+    ...defaultProps != null ? defaultProps : {},
+    ...extraProps != null ? extraProps : {},
+    ...isOptionBased ? { options: field.options } : {}
+  };
+  if (form) {
+    hostProps[valueProp] = current;
+    hostProps[changeProp] = onChange;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Component, { ...hostProps });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CanvasAPI,
+  EventBus,
+  FormProvider,
+  Provider,
+  Wrapper,
+  createInputRegistry,
+  resolveInputDescriptor,
+  useFormApi,
+  useFormField,
+  useFormSelections,
+  useInputs,
+  useOptionalFormApi
+});
+//# sourceMappingURL=index.cjs.map