@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_node-chunks/chunk-4FEANXWU.js

@@ -0,0 +1,1986 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  nanoid
+} from "./chunk-TEQGGSP7.js";
+import {
+  isEqual
+} from "./chunk-OWNFOGTA.js";
+import {
+  deserializeError,
+  serializeError
+} from "./chunk-3W7F2B7P.js";
+import {
+  OpenServiceAsyncRecipeError,
+  OpenServiceAsyncSchemaError,
+  OpenServiceCyclicStateError,
+  OpenServiceInternalServiceError,
+  OpenServiceInvalidStaticPathError,
+  OpenServiceLoadedDrainExceededError,
+  OpenServiceMissingChannelError,
+  OpenServiceMissingServiceError,
+  OpenServiceOperationNameCollisionError,
+  OpenServiceRemoteCommandConfigDriftError,
+  OpenServiceRemoteCommandDisconnectedError,
+  OpenServiceRemoteCommandUnhandledError,
+  OpenServiceUnimplementedOperationError,
+  OpenServiceValidationError
+} from "./chunk-U5W53R2J.js";
+
+// src/channels/main.ts
+var isMulti = (args) => args.transports !== void 0, generateRandomId = () => Math.random().toString(16).slice(2), Channel = class {
+  constructor(input = {}) {
+    this.sender = generateRandomId();
+    this.events = {};
+    this.data = {};
+    this.transports = [];
+    this.isAsync = input.async || !1, isMulti(input) ? (this.transports = input.transports || [], this.transports.forEach((t2) => {
+      t2.setHandler((event) => this.handleEvent(event));
+    })) : this.transports = input.transport ? [input.transport] : [], this.transports.forEach((t2) => {
+      t2.setHandler((event) => this.handleEvent(event));
+    });
+  }
+  get hasTransport() {
+    return this.transports.length > 0;
+  }
+  addListener(eventName, listener) {
+    this.events[eventName] = this.events[eventName] || [], this.events[eventName].push(listener);
+  }
+  emit(eventName, ...args) {
+    let event = { type: eventName, args, from: this.sender }, options = {};
+    args.length >= 1 && args[0] && args[0].options && (options = args[0].options);
+    let handler = () => {
+      this.transports.forEach((t2) => {
+        t2.send(event, options);
+      }), this.handleEvent(event);
+    };
+    this.isAsync ? setImmediate(handler) : handler();
+  }
+  last(eventName) {
+    return this.data[eventName];
+  }
+  eventNames() {
+    return Object.keys(this.events);
+  }
+  listenerCount(eventName) {
+    let listeners = this.listeners(eventName);
+    return listeners ? listeners.length : 0;
+  }
+  listeners(eventName) {
+    return this.events[eventName] || void 0;
+  }
+  once(eventName, listener) {
+    let onceListener = this.onceListener(eventName, listener);
+    this.addListener(eventName, onceListener);
+  }
+  removeAllListeners(eventName) {
+    eventName ? this.events[eventName] && delete this.events[eventName] : this.events = {};
+  }
+  removeListener(eventName, listener) {
+    let listeners = this.listeners(eventName);
+    listeners && (this.events[eventName] = listeners.filter((l3) => l3 !== listener));
+  }
+  on(eventName, listener) {
+    this.addListener(eventName, listener);
+  }
+  off(eventName, listener) {
+    this.removeListener(eventName, listener);
+  }
+  /**
+   * Deliver an event to local listeners without sending it to this channel's transports.
+   */
+  receive(event) {
+    this.handleEvent(event);
+  }
+  handleEvent(event) {
+    let listeners = this.listeners(event.type);
+    listeners && listeners.length && listeners.forEach((fn) => {
+      fn.apply(event, event.args);
+    }), this.data[event.type] = event.args;
+  }
+  onceListener(eventName, listener) {
+    let onceListener = (...args) => (this.removeListener(eventName, onceListener), listener(...args));
+    return onceListener;
+  }
+};
+
+// src/channels/channel-slot.ts
+var channel;
+function syncGlobalSlot(next) {
+  globalThis.__STORYBOOK_ADDONS_CHANNEL__ = next;
+}
+function getChannel() {
+  let fromGlobal = globalThis.__STORYBOOK_ADDONS_CHANNEL__;
+  return fromGlobal && (channel = fromGlobal), channel ?? null;
+}
+function setChannel(next) {
+  channel = next ?? void 0, syncGlobalSlot(channel);
+}
+function installNoopChannel() {
+  setChannel(new Channel({}));
+}
+function ensureChannel() {
+  getChannel() || installNoopChannel();
+}
+typeof window > "u" && ensureChannel();
+
+// src/shared/open-service/service-channel.ts
+import * as v from "valibot";
+
+// src/shared/open-service/plain-object.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]), MAX_DEPTH = 256;
+function isReservedKey(key) {
+  return FORBIDDEN_KEYS.has(key) || key.startsWith("$");
+}
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isPlainObject(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function clonePlain(value, depth = 0) {
+  if (value === null || typeof value != "object")
+    return value;
+  if (depth > MAX_DEPTH)
+    throw new OpenServiceCyclicStateError();
+  if (Array.isArray(value))
+    return value.map((entry) => clonePlain(entry, depth + 1));
+  let copy = {};
+  for (let key of Object.keys(value)) {
+    let entry = value[key];
+    isReservedKey(key) || entry === void 0 || (copy[key] = clonePlain(entry, depth + 1));
+  }
+  return copy;
+}
+
+// src/shared/open-service/service-channel.ts
+var SERVICE_SYNC_REQUEST = "services:sync-request", SERVICE_SYNC_REPLY = "services:sync-reply", SERVICE_ENTRY = "services:entry", SERVICE_COMMAND_INVOKE = "services:command-invoke", SERVICE_COMMAND_ACK = "services:command-ack", SERVICE_COMMAND_RESULT = "services:command-result", SERVICE_COMMAND_ERROR = "services:command-error", SERVICE_COMMAND_UNHANDLED = "services:command-unhandled", stateSnapshotSchema = v.custom(isPlainObject), nonNegativeSafeInteger = v.pipe(v.number(), v.safeInteger(), v.minValue(0)), positiveSafeInteger = v.pipe(v.number(), v.safeInteger(), v.minValue(1)), RFC_6901_ENCODED_SEGMENT = /^(?:[^~]|~[01])*$/;
+function decodeSegment(encoded) {
+  return encoded.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function encodePointer(segments) {
+  return segments.map((segment) => `/${segment.replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+}
+function decodePointer(pointer) {
+  return pointer === "" ? [] : pointer.slice(1).split("/").map(decodeSegment);
+}
+function isRfc6901Pointer(pointer) {
+  return pointer.startsWith("/") ? pointer.slice(1).split("/").every((encoded) => RFC_6901_ENCODED_SEGMENT.test(encoded) && !isReservedKey(decodeSegment(encoded))) : !1;
+}
+var jsonPointerSchema = v.pipe(v.string(), v.check(isRfc6901Pointer)), jsonPatchOperationSchema = v.variant("op", [
+  v.object({ op: v.literal("add"), path: jsonPointerSchema, value: v.unknown() }),
+  v.object({ op: v.literal("replace"), path: jsonPointerSchema, value: v.unknown() }),
+  v.object({ op: v.literal("remove"), path: jsonPointerSchema })
+]), entryStampSchema = v.object({
+  seq: positiveSafeInteger,
+  runtimeId: v.string(),
+  counter: positiveSafeInteger
+});
+function entryStampKey(stamp) {
+  return `${stamp.seq}:${stamp.runtimeId}:${stamp.counter}`;
+}
+var entrySchema = v.object({
+  serviceId: v.string(),
+  stamp: entryStampSchema,
+  command: v.string(),
+  patch: v.pipe(v.array(jsonPatchOperationSchema), v.minLength(1))
+}), frontierSchema = v.object({
+  vector: v.record(v.string(), nonNegativeSafeInteger),
+  clock: nonNegativeSafeInteger
+}), syncRequestSchema = v.object({
+  serviceId: v.string(),
+  runtimeId: v.string(),
+  frontier: frontierSchema
+}), syncReplySchema = v.object({
+  serviceId: v.string(),
+  runtimeId: v.string(),
+  frontier: frontierSchema,
+  state: stateSnapshotSchema
+}), commandInvokeSchema = v.object({
+  serviceId: v.string(),
+  commandName: v.string(),
+  input: v.optional(v.unknown()),
+  callId: v.string(),
+  runtimeId: v.string()
+}), commandAckSchema = v.object({
+  serviceId: v.string(),
+  callId: v.string(),
+  runtimeId: v.string()
+}), commandUnhandledSchema = v.object({
+  serviceId: v.string(),
+  callId: v.string()
+}), commandResultSchema = v.object({
+  serviceId: v.string(),
+  callId: v.string(),
+  result: v.optional(v.unknown()),
+  runtimeId: v.string()
+}), commandErrorSchema = v.object({
+  serviceId: v.string(),
+  callId: v.string(),
+  error: v.custom(
+    (value) => typeof value == "object" && value !== null && !Array.isArray(value)
+  ),
+  runtimeId: v.string()
+});
+function generateRuntimeId() {
+  return nanoid();
+}
+function generateCallId() {
+  return nanoid();
+}
+
+// ../../node_modules/@preact/signals-core/dist/signals-core.mjs
+var i = /* @__PURE__ */ Symbol.for("preact-signals");
+function t() {
+  if (e > 1) {
+    e--;
+    return;
+  }
+  let i3, t2 = !1;
+  for ((function() {
+    let i4 = f;
+    for (f = void 0; i4 !== void 0; ) {
+      let t3 = i4.S;
+      if (t3.v === i4.v) for (let n3 = t3.t; n3 !== void 0; n3 = n3.x) n3.i === i4.i && (n3.i = t3.i);
+      i4 = i4.o;
+    }
+  })(); h !== void 0; ) {
+    let n3 = h;
+    for (h = void 0, c++; n3 !== void 0; ) {
+      let o3 = n3.u;
+      if (n3.u = void 0, n3.f &= -3, !(8 & n3.f) && w(n3)) try {
+        n3.c();
+      } catch (n4) {
+        t2 || (i3 = n4, t2 = !0);
+      }
+      n3 = o3;
+    }
+  }
+  if (c = 0, e--, t2) throw i3;
+}
+function n(i3) {
+  if (e > 0) return i3();
+  d = ++u, e++;
+  try {
+    return i3();
+  } finally {
+    t();
+  }
+}
+var o, s, h;
+function r(i3) {
+  let t2 = o, n3 = s;
+  o = void 0, s = void 0;
+  try {
+    return i3();
+  } finally {
+    o = t2, s = n3;
+  }
+}
+var f, e = 0, c = 0, u = 0, d = 0, v2 = 0;
+function l(i3) {
+  if (o === void 0) return;
+  let t2 = i3.n;
+  if (t2 === void 0 || t2.t !== o)
+    return t2 = { i: 0, S: i3, p: o.s, n: void 0, t: o, e: void 0, x: void 0, r: t2 }, o.s !== void 0 && (o.s.n = t2), o.s = t2, i3.n = t2, 32 & o.f && i3.S(t2), t2;
+  if (t2.i === -1)
+    return t2.i = 0, t2.n !== void 0 && (t2.n.p = t2.p, t2.p !== void 0 && (t2.p.n = t2.n), t2.p = o.s, t2.n = void 0, o.s.n = t2, o.s = t2), t2;
+}
+function a(i3, t2) {
+  this.v = i3, this.i = 0, this.n = void 0, this.t = void 0, this.l = 0, this.W = t2?.watched, this.Z = t2?.unwatched, this.name = t2?.name;
+}
+a.prototype.brand = i;
+a.prototype.h = function() {
+  return !0;
+};
+a.prototype.S = function(i3) {
+  let t2 = this.t;
+  t2 !== i3 && i3.e === void 0 && (i3.x = t2, this.t = i3, t2 !== void 0 ? t2.e = i3 : r(() => {
+    var i4;
+    (i4 = this.W) == null || i4.call(this);
+  }));
+};
+a.prototype.U = function(i3) {
+  if (this.t !== void 0) {
+    let t2 = i3.e, n3 = i3.x;
+    t2 !== void 0 && (t2.x = n3, i3.e = void 0), n3 !== void 0 && (n3.e = t2, i3.x = void 0), i3 === this.t && (this.t = n3, n3 === void 0 && r(() => {
+      var i4;
+      (i4 = this.Z) == null || i4.call(this);
+    }));
+  }
+};
+a.prototype.subscribe = function(i3) {
+  return j(() => {
+    let t2 = this.value;
+    r(() => i3(t2));
+  }, { name: "sub" });
+};
+a.prototype.valueOf = function() {
+  return this.value;
+};
+a.prototype.toString = function() {
+  return this.value + "";
+};
+a.prototype.toJSON = function() {
+  return this.value;
+};
+a.prototype.peek = function() {
+  return r(() => this.value);
+};
+Object.defineProperty(a.prototype, "value", { get() {
+  let i3 = l(this);
+  return i3 !== void 0 && (i3.i = this.i), this.v;
+}, set(i3) {
+  if (i3 !== this.v) {
+    if (c > 100) throw new Error("Cycle detected");
+    (function(i4) {
+      e !== 0 && c === 0 && i4.l !== d && (i4.l = d, f = { S: i4, v: i4.v, i: i4.i, o: f });
+    })(this), this.v = i3, this.i++, v2++, e++;
+    try {
+      for (let i4 = this.t; i4 !== void 0; i4 = i4.x) i4.t.N();
+    } finally {
+      t();
+    }
+  }
+} });
+function y(i3, t2) {
+  return new a(i3, t2);
+}
+function w(i3) {
+  for (let t2 = i3.s; t2 !== void 0; t2 = t2.n) if (t2.S.i !== t2.i || !t2.S.h() || t2.S.i !== t2.i) return !0;
+  return !1;
+}
+function _(i3) {
+  for (let t2 = i3.s; t2 !== void 0; t2 = t2.n) {
+    let n3 = t2.S.n;
+    if (n3 !== void 0 && (t2.r = n3), t2.S.n = t2, t2.i = -1, t2.n === void 0) {
+      i3.s = t2;
+      break;
+    }
+  }
+}
+function b(i3) {
+  let t2, n3 = i3.s;
+  for (; n3 !== void 0; ) {
+    let i4 = n3.p;
+    n3.i === -1 ? (n3.S.U(n3), i4 !== void 0 && (i4.n = n3.n), n3.n !== void 0 && (n3.n.p = i4)) : t2 = n3, n3.S.n = n3.r, n3.r !== void 0 && (n3.r = void 0), n3 = i4;
+  }
+  i3.s = t2;
+}
+function p(i3, t2) {
+  a.call(this, void 0, t2), this.x = i3, this.s = void 0, this.g = v2 - 1, this.f = 4;
+}
+p.prototype = new a();
+p.prototype.h = function() {
+  if (this.f &= -3, 1 & this.f) return !1;
+  if ((36 & this.f) == 32 || (this.f &= -5, this.g === v2)) return !0;
+  if (this.g = v2, this.f |= 1, this.i > 0 && !w(this))
+    return this.f &= -2, !0;
+  let i3 = o;
+  try {
+    _(this), o = this;
+    let i4 = this.x();
+    (16 & this.f || this.v !== i4 || this.i === 0) && (this.v = i4, this.f &= -17, this.i++);
+  } catch (i4) {
+    this.v = i4, this.f |= 16, this.i++;
+  }
+  return o = i3, b(this), this.f &= -2, !0;
+};
+p.prototype.S = function(i3) {
+  if (this.t === void 0) {
+    this.f |= 36;
+    for (let i4 = this.s; i4 !== void 0; i4 = i4.n) i4.S.S(i4);
+  }
+  a.prototype.S.call(this, i3);
+};
+p.prototype.U = function(i3) {
+  if (this.t !== void 0 && (a.prototype.U.call(this, i3), this.t === void 0)) {
+    this.f &= -33;
+    for (let i4 = this.s; i4 !== void 0; i4 = i4.n) i4.S.U(i4);
+  }
+};
+p.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (let i3 = this.t; i3 !== void 0; i3 = i3.x) i3.t.N();
+  }
+};
+Object.defineProperty(p.prototype, "value", { get() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  let i3 = l(this);
+  if (this.h(), i3 !== void 0 && (i3.i = this.i), 16 & this.f) throw this.v;
+  return this.v;
+} });
+function g(i3, t2) {
+  return new p(i3, t2);
+}
+function S(i3) {
+  let n3 = i3.m;
+  if (i3.m = void 0, typeof n3 == "function") {
+    e++;
+    let s3 = o;
+    o = void 0;
+    try {
+      n3();
+    } catch (t2) {
+      throw i3.f &= -2, i3.f |= 8, m(i3), t2;
+    } finally {
+      o = s3, t();
+    }
+  }
+}
+function m(i3) {
+  for (let t2 = i3.s; t2 !== void 0; t2 = t2.n) t2.S.U(t2);
+  i3.x = void 0, i3.s = void 0, S(i3);
+}
+function x(i3) {
+  if (o !== this) throw new Error("Out-of-order effect");
+  b(this), o = i3, this.f &= -2, 8 & this.f && m(this), t();
+}
+function E(i3, t2) {
+  this.x = i3, this.m = void 0, this.s = void 0, this.u = void 0, this.f = 32, this.name = t2?.name, s && s.push(this);
+}
+E.prototype.c = function() {
+  let i3 = this.S();
+  try {
+    if (8 & this.f || this.x === void 0) return;
+    let t2 = this.x();
+    typeof t2 == "function" && (this.m = t2);
+  } finally {
+    i3();
+  }
+};
+E.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1, this.f &= -9, S(this), _(this), e++;
+  let i3 = o;
+  return o = this, x.bind(this, i3);
+};
+E.prototype.N = function() {
+  2 & this.f || (this.f |= 2, this.u = h, h = this);
+};
+E.prototype.d = function() {
+  this.f |= 8, 1 & this.f || m(this);
+};
+E.prototype.dispose = function() {
+  this.d();
+};
+function j(i3, t2) {
+  let n3 = new E(i3, t2);
+  try {
+    n3.c();
+  } catch (i4) {
+    throw n3.d(), i4;
+  }
+  let o3 = n3.d.bind(n3);
+  return o3[Symbol.dispose] = o3, o3;
+}
+
+// ../../node_modules/deepsignal/core/dist/deepsignal-core.mjs
+var n2 = /* @__PURE__ */ new WeakMap(), s2 = /* @__PURE__ */ new WeakMap(), a2 = /* @__PURE__ */ new WeakMap(), o2 = /* @__PURE__ */ new WeakSet(), l2 = /* @__PURE__ */ new WeakMap(), c2 = /^\$/, f2 = Object.getOwnPropertyDescriptor, g2 = !1, u2 = (e2) => {
+  if (!R(e2)) throw new Error("This object can't be observed.");
+  return s2.has(e2) || s2.set(e2, p2(e2, v3)), s2.get(e2);
+}, i2 = (e2, t2) => {
+  g2 = !0;
+  let r2 = e2[t2];
+  try {
+    g2 = !1;
+  } catch {
+  }
+  return r2;
+};
+var p2 = (e2, t2) => {
+  let r2 = new Proxy(e2, t2);
+  return o2.add(r2), r2;
+}, y2 = () => {
+  throw new Error("Don't mutate the signals directly.");
+}, w2 = (e2) => (o3, l3, u3) => {
+  var i3;
+  if (g2) return Reflect.get(o3, l3, u3);
+  let h2 = e2 || l3[0] === "$";
+  if (!e2 && h2 && Array.isArray(o3)) {
+    if (l3 === "$") return a2.has(o3) || a2.set(o3, p2(o3, d2)), a2.get(o3);
+    h2 = l3 === "$length";
+  }
+  n2.has(u3) || n2.set(u3, /* @__PURE__ */ new Map());
+  let y3 = n2.get(u3), w3 = h2 ? l3.replace(c2, "") : l3;
+  if (y3.has(w3) || typeof ((i3 = f2(o3, w3)) == null ? void 0 : i3.get) != "function") {
+    let e3 = Reflect.get(o3, w3, u3);
+    if (h2 && typeof e3 == "function") return;
+    if (typeof w3 == "symbol" && b2.has(w3)) return e3;
+    y3.has(w3) || (R(e3) && (s2.has(e3) || s2.set(e3, p2(e3, v3)), e3 = s2.get(e3)), y3.set(w3, y(e3)));
+  } else y3.set(w3, g(() => Reflect.get(o3, w3, u3)));
+  return h2 ? y3.get(w3) : y3.get(w3).value;
+}, v3 = { get: w2(!1), set(r2, a3, o3, g3) {
+  var u3;
+  if (typeof ((u3 = f2(r2, a3)) == null ? void 0 : u3.set) == "function") return Reflect.set(r2, a3, o3, g3);
+  n2.has(g3) || n2.set(g3, /* @__PURE__ */ new Map());
+  let i3 = n2.get(g3);
+  if (a3[0] === "$") {
+    o3 instanceof a || y2();
+    let t2 = a3.replace(c2, "");
+    return i3.set(t2, o3), Reflect.set(r2, t2, o3.peek(), g3);
+  }
+  {
+    let e2 = o3;
+    R(o3) && (s2.has(o3) || s2.set(o3, p2(o3, v3)), e2 = s2.get(o3));
+    let n3 = !(a3 in r2), c3 = Reflect.set(r2, a3, o3, g3);
+    return i3.has(a3) ? i3.get(a3).value = e2 : i3.set(a3, y(e2)), n3 && l2.has(r2) && l2.get(r2).value++, Array.isArray(r2) && i3.has("length") && (i3.get("length").value = r2.length), c3;
+  }
+}, deleteProperty(e2, t2) {
+  t2[0] === "$" && y2();
+  let r2 = n2.get(s2.get(e2)), a3 = Reflect.deleteProperty(e2, t2);
+  return r2 && r2.has(t2) && (r2.get(t2).value = void 0), l2.has(e2) && l2.get(e2).value++, a3;
+}, ownKeys: (e2) => (l2.has(e2) || l2.set(e2, y(0)), l2._ = l2.get(e2).value, Reflect.ownKeys(e2)) }, d2 = { get: w2(!0), set: y2, deleteProperty: y2 }, b2 = new Set(Object.getOwnPropertyNames(Symbol).map((e2) => Symbol[e2]).filter((e2) => typeof e2 == "symbol")), m2 = /* @__PURE__ */ new Set([Object, Array]), R = (e2) => typeof e2 == "object" && e2 !== null && m2.has(e2.constructor) && !o2.has(e2);
+
+// src/shared/open-service/patch-recorder.ts
+function peekProp(obj, key) {
+  return i2(obj, key);
+}
+function isPrimitive(value) {
+  return value === null || typeof value != "object";
+}
+function ownValue(inner, name) {
+  let existed = hasOwn(inner, name);
+  return { existed, firstValue: existed ? clonePlain(peekProp(inner, name)) : void 0 };
+}
+var activeDrafts = /* @__PURE__ */ new WeakMap();
+function readPath(root, segments) {
+  let current = root;
+  for (let segment of segments) {
+    if (current === null || typeof current != "object")
+      return { found: !1, value: void 0 };
+    if (!hasOwn(current, segment))
+      return { found: !1, value: void 0 };
+    current = peekProp(current, segment);
+  }
+  return { found: !0, value: current };
+}
+function recordPatch(state, mutate, author) {
+  let activeDraft = activeDrafts.get(state);
+  if (activeDraft) {
+    let nested = mutate(activeDraft);
+    if (isThenable(nested))
+      throw Promise.resolve(nested).catch(() => {
+      }), new OpenServiceAsyncRecipeError();
+    return;
+  }
+  let root = state, touches = /* @__PURE__ */ new Map(), order = [], wrapperByTarget = /* @__PURE__ */ new WeakMap(), targetByWrapper = /* @__PURE__ */ new WeakMap(), revokes = [], preRecipeValue = (segments) => {
+    let { found, value } = readPath(root, segments);
+    if (!found)
+      return { existed: !1, firstValue: void 0 };
+    let snapshot = clonePlain(value), prefix = encodePointer(segments);
+    for (let pointer of order.toReversed()) {
+      if (!pointer.startsWith(`${prefix}/`))
+        continue;
+      let descendant = touches.get(pointer), parent = snapshot, relative = descendant.segments.slice(segments.length);
+      for (let segment of relative.slice(0, -1))
+        parent = parent !== null && typeof parent == "object" ? parent[segment] : void 0;
+      if (parent === null || typeof parent != "object")
+        continue;
+      let key = relative[relative.length - 1];
+      descendant.existed ? parent[key] = clonePlain(descendant.firstValue) : delete parent[key];
+    }
+    return { existed: !0, firstValue: snapshot };
+  }, note = (segments, capture) => {
+    let pointer = encodePointer(segments);
+    if (touches.has(pointer))
+      return;
+    let prefix = `${pointer}/`, subsumesEarlierTouch = order.some((recorded) => recorded.startsWith(prefix));
+    touches.set(pointer, {
+      segments,
+      ...subsumesEarlierTouch ? preRecipeValue(segments) : capture()
+    }), order.push(pointer);
+  }, noteArray = (arrayRoot) => {
+    note(arrayRoot.path, () => ({ existed: !0, firstValue: clonePlain(arrayRoot.target) }));
+  }, storedValue = (value) => value === null || typeof value != "object" ? value : clonePlain(targetByWrapper.get(value) ?? value), isUnchangedAssignment = (inner, name, value) => {
+    if (!hasOwn(inner, name))
+      return !1;
+    if (Object.is(peekProp(inner, name), value))
+      return !0;
+    if (value !== null && typeof value == "object") {
+      let target = targetByWrapper.get(value);
+      return target !== void 0 && Object.is(Reflect.get(inner, name), target);
+    }
+    return !1;
+  }, wrap = (target, path, arrayRoot) => {
+    let cached = wrapperByTarget.get(target);
+    if (cached)
+      return cached;
+    let effectiveArrayRoot = arrayRoot ?? (Array.isArray(target) ? { path, target } : null), { proxy, revoke } = Proxy.revocable(target, {
+      get(inner, key) {
+        if (typeof key == "symbol")
+          return Reflect.get(inner, key);
+        if (FORBIDDEN_KEYS.has(key) || key.startsWith("$"))
+          return;
+        let value = Reflect.get(inner, key);
+        return typeof value == "function" ? value : value !== null && typeof value == "object" ? wrap(value, path.concat(String(key)), effectiveArrayRoot) : value;
+      },
+      set(inner, key, value) {
+        if (typeof key == "symbol")
+          return Reflect.set(inner, key, value);
+        let name = String(key);
+        if (FORBIDDEN_KEYS.has(name))
+          return !0;
+        if (name.startsWith("$")) {
+          let plain = name.slice(1);
+          return FORBIDDEN_KEYS.has(plain) ? !0 : (note(path.concat(plain), () => ownValue(inner, plain)), Reflect.set(inner, key, value));
+        }
+        if (isUnchangedAssignment(inner, name, value))
+          return !0;
+        if (effectiveArrayRoot)
+          return noteArray(effectiveArrayRoot), Reflect.set(inner, name, storedValue(value));
+        let segments = path.concat(name);
+        return value === void 0 ? hasOwn(inner, name) ? (note(segments, () => ownValue(inner, name)), Reflect.deleteProperty(inner, name)) : !0 : (note(segments, () => ownValue(inner, name)), Reflect.set(inner, name, storedValue(value)));
+      },
+      deleteProperty(inner, key) {
+        if (typeof key == "symbol")
+          return Reflect.deleteProperty(inner, key);
+        let name = String(key);
+        return FORBIDDEN_KEYS.has(name) ? !0 : name.startsWith("$") ? Reflect.deleteProperty(inner, key) : hasOwn(inner, name) ? effectiveArrayRoot ? (noteArray(effectiveArrayRoot), Reflect.deleteProperty(inner, name)) : (note(path.concat(name), () => ownValue(inner, name)), Reflect.deleteProperty(inner, name)) : !0;
+      }
+    });
+    return revokes.push(revoke), wrapperByTarget.set(target, proxy), targetByWrapper.set(proxy, target), proxy;
+  }, flush = () => {
+    let touched = new Set(order), ops = [], inverse = [];
+    for (let pointer of order) {
+      let touch = touches.get(pointer);
+      if (touch.segments.some((_2, index) => index === 0 ? !1 : touched.has(encodePointer(touch.segments.slice(0, index)))))
+        continue;
+      let { found, value } = readPath(root, touch.segments);
+      if (!found) {
+        touch.existed && (ops.push({ op: "remove", path: pointer }), inverse.push({ op: "add", path: pointer, value: touch.firstValue }));
+        continue;
+      }
+      isPrimitive(value) && Object.is(value, touch.firstValue) || (ops.push({
+        op: touch.existed ? "replace" : "add",
+        path: pointer,
+        value: clonePlain(value)
+      }), inverse.push(
+        touch.existed ? { op: "replace", path: pointer, value: touch.firstValue } : { op: "remove", path: pointer }
+      ));
+    }
+    return { ops, inverse };
+  };
+  n(() => {
+    r(() => {
+      let draft = wrap(state, [], null);
+      activeDrafts.set(state, draft);
+      try {
+        let result = mutate(draft);
+        if (isThenable(result))
+          throw Promise.resolve(result).catch(() => {
+          }), new OpenServiceAsyncRecipeError();
+      } finally {
+        activeDrafts.delete(state);
+        for (let revoke of revokes)
+          revoke();
+        let recorded = flush();
+        recorded.ops.length > 0 && author(recorded);
+      }
+    });
+  });
+}
+function isThenable(value) {
+  return value !== null && typeof value == "object" && typeof value.then == "function";
+}
+
+// src/shared/open-service/query-state.ts
+function buildQueryState(data, lifecycle) {
+  let isPending = lifecycle.status === "pending", isLoading = lifecycle.loadStatus === "loading";
+  return {
+    data,
+    error: lifecycle.error,
+    status: lifecycle.status,
+    loadStatus: lifecycle.loadStatus,
+    isPending,
+    isSuccess: lifecycle.status === "success",
+    isError: lifecycle.status === "error",
+    isLoading,
+    isInitialLoading: isPending && isLoading && data === void 0,
+    isRefreshing: isLoading && !isPending
+  };
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+
+// src/shared/open-service/service-validation.ts
+function rethrowAsync(error) {
+  queueMicrotask(() => {
+    throw error;
+  });
+}
+async function validateSchema(schema, value, meta) {
+  let validationResult = await schema["~standard"].validate(value);
+  if (validationResult.issues)
+    throw new OpenServiceValidationError({ ...meta, issues: validationResult.issues });
+  return validationResult.value;
+}
+function validateSchemaSync(schema, value, meta) {
+  let validationResult = schema["~standard"].validate(value);
+  if (validationResult instanceof Promise)
+    throw new OpenServiceAsyncSchemaError({
+      kind: meta.kind,
+      serviceId: meta.serviceId,
+      name: meta.name,
+      phase: meta.phase
+    });
+  if (validationResult.issues)
+    throw new OpenServiceValidationError({ ...meta, issues: validationResult.issues });
+  return validationResult.value;
+}
+
+// src/shared/open-service/query-runtime.ts
+var MAX_DRAIN_ITERATIONS = 32, inFlightLoads = /* @__PURE__ */ new Map(), nextLoadScopeSequence = 0, nextLoadScopeId = () => String(nextLoadScopeSequence += 1), activeHandlerLoadSession, EMPTY_SET = /* @__PURE__ */ new Set();
+function stableHash(value) {
+  let encode = (raw) => {
+    if (raw === void 0)
+      return { __t: "undefined" };
+    if (raw === null || typeof raw != "object")
+      return raw;
+    if (Array.isArray(raw))
+      return raw.map(encode);
+    let sorted = {};
+    for (let k of Object.keys(raw).sort())
+      sorted[k] = encode(raw[k]);
+    return { __t: "object", value: sorted };
+  };
+  return JSON.stringify(encode(value));
+}
+function makeInFlightKey(loadScopeId, loadKey) {
+  return `${loadScopeId}::${loadKey}`;
+}
+function makeLoadKey(serviceId, queryName, validatedInput) {
+  return `${serviceId}::${queryName}::${stableHash(validatedInput)}`;
+}
+function surfaceRejections(settlements) {
+  let rejections = settlements.filter((s3) => s3.status === "rejected");
+  if (rejections.length === 0)
+    return;
+  let [first, ...rest] = rejections.map((r2) => r2.reason);
+  if (rest.length > 0 && first instanceof Error && Reflect.get(first, "cause") === void 0)
+    try {
+      Reflect.set(first, "cause", { aggregated: rest });
+    } catch {
+    }
+  throw first;
+}
+async function drainCollector(collector, settledKeys, serviceId, queryName) {
+  let iterations = 0;
+  for (; collector.size > 0; ) {
+    if (iterations++ > MAX_DRAIN_ITERATIONS)
+      throw new OpenServiceLoadedDrainExceededError({
+        serviceId,
+        name: queryName,
+        iterations: MAX_DRAIN_ITERATIONS
+      });
+    let pending = [...collector];
+    collector.clear();
+    let settlements = await Promise.allSettled(pending.map((entry) => entry.promise));
+    if (settledKeys)
+      for (let entry of pending)
+        settledKeys.add(entry.key);
+    surfaceRejections(settlements);
+  }
+}
+function detachSnapshot(value) {
+  return value === null || typeof value != "object" ? value : JSON.parse(JSON.stringify(value));
+}
+function validateQueryInput(refs, queryName, queryDef, input) {
+  return validateSchemaSync(queryDef.input, input, {
+    kind: "query",
+    serviceId: refs.serviceId,
+    name: queryName,
+    phase: "input"
+  });
+}
+function validateQueryOutput(refs, queryName, queryDef, output) {
+  return validateSchemaSync(queryDef.output, output, {
+    kind: "query",
+    serviceId: refs.serviceId,
+    name: queryName,
+    phase: "output"
+  });
+}
+function runHandlerSync(refs, queryName, queryDef, validatedInput, selfQueries, getService2) {
+  if (!queryDef.handler)
+    throw new OpenServiceUnimplementedOperationError({
+      kind: "query",
+      serviceId: refs.serviceId,
+      name: queryName
+    });
+  let handlerCtx = { self: {
+    get state() {
+      return refs.state;
+    },
+    queries: selfQueries
+  }, getService: getService2 };
+  return queryDef.handler(validatedInput, handlerCtx);
+}
+function createQueryGet(refs, queryName, queryDef, selfQueries, fireLoad) {
+  return function(input) {
+    let validatedInput = validateQueryInput(
+      refs,
+      queryName,
+      queryDef,
+      arguments.length === 0 ? void 0 : input
+    );
+    return queryDef.load && fireLoad?.(validatedInput), validateQueryOutput(
+      refs,
+      queryName,
+      queryDef,
+      runHandlerSync(
+        refs,
+        queryName,
+        queryDef,
+        validatedInput,
+        selfQueries,
+        refs.registryApi.getService
+      )
+    );
+  };
+}
+function triggerLoad(refs, queryName, queryDef, validatedInput, loadKey, parentAncestorChain) {
+  let inFlightKey = makeInFlightKey(refs.loadScopeId, loadKey), existing = inFlightLoads.get(inFlightKey);
+  if (existing)
+    return existing;
+  let extendedChain = new Set(parentAncestorChain);
+  extendedChain.add(loadKey);
+  let promise = Promise.resolve().then(() => runLoadBody(refs, queryName, queryDef, validatedInput, extendedChain)).finally(() => {
+    inFlightLoads.get(inFlightKey) === promise && inFlightLoads.delete(inFlightKey);
+  });
+  return inFlightLoads.set(inFlightKey, promise), promise;
+}
+async function runLoadBody(refs, queryName, queryDef, validatedInput, ancestorChain) {
+  if (!queryDef.load)
+    return;
+  let collector = /* @__PURE__ */ new Set(), wrappedQueries = buildLoadWrappedQueries(refs, ancestorChain, collector), loadCtx = { self: {
+    get state() {
+      return refs.state;
+    },
+    queries: wrappedQueries,
+    commands: refs.getLoadCommands()
+  }, getService: refs.registryApi.getService };
+  await Promise.resolve(queryDef.load(validatedInput, loadCtx)), await drainCollector(collector, void 0, refs.serviceId, queryName);
+}
+async function runReactiveLoad(refs, queryName, queryDef, validatedInput, isCurrent) {
+  if (!queryDef.load)
+    return;
+  let loadCtx = { self: {
+    get state() {
+      return refs.state;
+    },
+    // Reactive-load reads must keep dependency loads warm. `.get()` on a default query is a pure
+    // read and never fires a load, so the body sees fire-and-forget wrappers instead: reading a
+    // dependency triggers its load (deduped while in flight) without awaiting a drain.
+    queries: refs.reactiveLoadQueries,
+    commands: refs.buildGatedCommands(isCurrent)
+  }, getService: refs.registryApi.getService };
+  await Promise.resolve(queryDef.load(validatedInput, loadCtx));
+}
+function buildReactiveLoadQueries(refs) {
+  let wrappedQueries = {};
+  for (let [name, queryDef] of refs.queryDefinitions) {
+    let defaultQuery = refs.defaultQueries[name], get = createQueryGet(refs, name, queryDef, wrappedQueries, (validatedInput) => {
+      let loadKey = makeLoadKey(refs.serviceId, name, validatedInput);
+      triggerLoad(refs, name, queryDef, validatedInput, loadKey, EMPTY_SET).catch(rethrowAsync);
+    });
+    wrappedQueries[name] = {
+      get,
+      loaded: defaultQuery.loaded,
+      subscribe: defaultQuery.subscribe
+    };
+  }
+  return wrappedQueries;
+}
+function buildLoadWrappedQueries(refs, ancestorChain, collector) {
+  let wrappedQueries = {};
+  for (let [name, queryDef] of refs.queryDefinitions) {
+    let defaultQuery = refs.defaultQueries[name], wrapped = {
+      get: createQueryGet(refs, name, queryDef, wrappedQueries, (validatedInput) => {
+        let loadKey = makeLoadKey(refs.serviceId, name, validatedInput), promise = triggerLoad(refs, name, queryDef, validatedInput, loadKey, ancestorChain);
+        ancestorChain.has(loadKey) || collector.add({ key: loadKey, promise });
+      }),
+      loaded(input) {
+        return runLoaded(
+          refs,
+          name,
+          queryDef,
+          arguments.length === 0 ? void 0 : input,
+          ancestorChain
+        );
+      },
+      subscribe: defaultQuery.subscribe
+    };
+    wrappedQueries[name] = wrapped;
+  }
+  return wrappedQueries;
+}
+async function runLoaded(refs, queryName, queryDef, rawInput, parentAncestorChain = EMPTY_SET) {
+  let validatedInput = validateQueryInput(refs, queryName, queryDef, rawInput), loadKey = makeLoadKey(refs.serviceId, queryName, validatedInput), ancestorChain = new Set(parentAncestorChain);
+  ancestorChain.add(loadKey);
+  let session = {
+    ancestorChain,
+    collector: /* @__PURE__ */ new Set(),
+    settledKeys: /* @__PURE__ */ new Set()
+  };
+  if (queryDef.load && !parentAncestorChain.has(loadKey)) {
+    let promise = triggerLoad(
+      refs,
+      queryName,
+      queryDef,
+      validatedInput,
+      loadKey,
+      parentAncestorChain
+    );
+    session.collector.add({ key: loadKey, promise });
+  }
+  let iterations = 0, hasMoreWork = !0;
+  for (; hasMoreWork; ) {
+    if (iterations++ > MAX_DRAIN_ITERATIONS)
+      throw new OpenServiceLoadedDrainExceededError({
+        serviceId: refs.serviceId,
+        name: queryName,
+        iterations: MAX_DRAIN_ITERATIONS
+      });
+    for (; session.collector.size > 0; ) {
+      let pending = [...session.collector];
+      session.collector.clear();
+      let settlements = await Promise.allSettled(pending.map((entry) => entry.promise));
+      for (let entry of pending)
+        session.settledKeys.add(entry.key);
+      surfaceRejections(settlements);
+    }
+    let previousSession2 = activeHandlerLoadSession;
+    activeHandlerLoadSession = session;
+    try {
+      runHandlerSync(
+        refs,
+        queryName,
+        queryDef,
+        validatedInput,
+        refs.defaultQueries,
+        refs.registryApi.getService
+      );
+    } catch {
+    } finally {
+      activeHandlerLoadSession = previousSession2;
+    }
+    hasMoreWork = session.collector.size > 0;
+  }
+  let previousSession = activeHandlerLoadSession;
+  activeHandlerLoadSession = session;
+  try {
+    return validateQueryOutput(
+      refs,
+      queryName,
+      queryDef,
+      runHandlerSync(
+        refs,
+        queryName,
+        queryDef,
+        validatedInput,
+        refs.defaultQueries,
+        refs.registryApi.getService
+      )
+    );
+  } finally {
+    activeHandlerLoadSession = previousSession;
+  }
+}
+function createDefaultQuery(refs, queryName, queryDef) {
+  let resolveInput = (input, argsLength) => argsLength === 0 ? void 0 : input;
+  return {
+    get: createQueryGet(refs, queryName, queryDef, refs.defaultQueries, (validatedInput) => {
+      let session = activeHandlerLoadSession;
+      if (!session)
+        return;
+      let loadKey = makeLoadKey(refs.serviceId, queryName, validatedInput);
+      if (!session.ancestorChain.has(loadKey) && !session.settledKeys.has(loadKey)) {
+        let promise = triggerLoad(
+          refs,
+          queryName,
+          queryDef,
+          validatedInput,
+          loadKey,
+          session.ancestorChain
+        );
+        session.collector.add({ key: loadKey, promise });
+      }
+    }),
+    loaded(input) {
+      return runLoaded(refs, queryName, queryDef, resolveInput(input, arguments.length));
+    },
+    subscribe: ((...args) => {
+      if (args.length === 1 && typeof args[0] == "function")
+        return subscribeToQuery(
+          refs,
+          queryName,
+          queryDef,
+          void 0,
+          void 0,
+          args[0]
+        );
+      if (args.length === 2 && typeof args[0] == "function" && typeof args[1] == "function")
+        return subscribeToQuery(
+          refs,
+          queryName,
+          queryDef,
+          void 0,
+          args[0],
+          args[1]
+        );
+      let [input, selectorOrCallback, maybeCallback] = args;
+      return subscribeToQuery(
+        refs,
+        queryName,
+        queryDef,
+        input,
+        maybeCallback ? selectorOrCallback : void 0,
+        maybeCallback ?? selectorOrCallback
+      );
+    })
+  };
+}
+function subscribeToQuery(refs, queryName, queryDef, rawInput, selector, callback) {
+  let active = !0, validatedInput;
+  try {
+    validatedInput = validateQueryInput(refs, queryName, queryDef, rawInput);
+  } catch (error) {
+    return callback(
+      buildQueryState(void 0, { status: "error", error: toError(error), loadStatus: "idle" })
+    ), () => {
+      active = !1;
+    };
+  }
+  let lifecycle = y({
+    status: queryDef.load ? "pending" : "success",
+    error: void 0,
+    loadStatus: "idle"
+  }), loadTeardown;
+  if (queryDef.load) {
+    let epoch = 0;
+    loadTeardown = j(() => {
+      let myEpoch = ++epoch, isCurrent = () => myEpoch === epoch, previous = r(() => lifecycle.value);
+      lifecycle.value = {
+        status: previous.status,
+        error: previous.error,
+        loadStatus: "loading"
+      }, runReactiveLoad(refs, queryName, queryDef, validatedInput, isCurrent).then(
+        () => {
+          isCurrent() && (lifecycle.value = { status: "success", error: void 0, loadStatus: "idle" });
+        },
+        (error) => {
+          isCurrent() && (lifecycle.value = { status: "error", error: toError(error), loadStatus: "idle" });
+        }
+      );
+    });
+  }
+  let comp = g(() => {
+    let output = runHandlerSync(
+      refs,
+      queryName,
+      queryDef,
+      validatedInput,
+      refs.defaultQueries,
+      refs.registryApi.getService
+    );
+    if (selector) {
+      let validated = r(() => validateQueryOutput(refs, queryName, queryDef, output));
+      return selector(output), detachSnapshot(selector(validated));
+    }
+    return detachSnapshot(validateQueryOutput(refs, queryName, queryDef, output));
+  }), hasEmitted = !1, lastEmitted, lastData, teardown = j(() => {
+    let life = lifecycle.value, data, status = life.status, error = life.error;
+    try {
+      data = comp.value, lastData = data;
+    } catch (handlerError) {
+      data = lastData, status = "error", error = toError(handlerError);
+    }
+    if (!active)
+      return;
+    let state = buildQueryState(data, { status, error, loadStatus: life.loadStatus });
+    hasEmitted && isEqual(state, lastEmitted) || (hasEmitted = !0, lastEmitted = state, callback(state));
+  });
+  return () => {
+    active = !1, teardown(), loadTeardown?.();
+  };
+}
+function buildQueries(refs) {
+  let result = {};
+  for (let [name, queryDef] of refs.queryDefinitions)
+    result[name] = createDefaultQuery(refs, name, queryDef);
+  return result;
+}
+
+// src/shared/open-service/service-sync.ts
+import { logger } from "@aussieljk/forkbook/internal/client-logger";
+
+// src/shared/open-service/json-patch.ts
+function parentAt(root, segments) {
+  let current = root;
+  for (let index = 0; index < segments.length - 1; index += 1) {
+    let segment = segments[index];
+    if (isReservedKey(segment) || !isPlainObject(current) || !hasOwn(current, segment))
+      return;
+    current = current[segment];
+  }
+  if (isPlainObject(current))
+    return { parent: current, key: segments[segments.length - 1] };
+}
+var MissingParentError = class extends Error {
+  constructor(path) {
+    super(`Missing parent for JSON Patch path ${path}`), this.name = "MissingParentError", this.path = path;
+  }
+};
+function applyJsonPatch(target, patch, onMissingRemove) {
+  let undo = [], inverse = [], currentPath = "";
+  try {
+    for (let operation of patch)
+      currentPath = operation.path, applyOne(target, operation, undo, inverse, onMissingRemove);
+    return { ok: !0, inverse: inverse.toReversed() };
+  } catch (error) {
+    for (let revert of undo.toReversed())
+      revert();
+    return error instanceof MissingParentError ? { ok: !1, path: error.path } : { ok: !1, path: currentPath };
+  }
+}
+function applyOne(target, operation, undo, inverse, onMissingRemove) {
+  if (!isRfc6901Pointer(operation.path))
+    throw new MissingParentError(operation.path);
+  let location = parentAt(target, decodePointer(operation.path));
+  if (!location || isReservedKey(location.key))
+    throw new MissingParentError(operation.path);
+  let { parent, key } = location;
+  switch (operation.op) {
+    case "add":
+    case "replace": {
+      let existed = hasOwn(parent, key), previous = existed ? clonePlain(parent[key]) : void 0;
+      parent[key] = clonePlain(operation.value), undo.push(() => {
+        existed ? parent[key] = previous : delete parent[key];
+      }), existed ? inverse.push({ op: "replace", path: operation.path, value: previous }) : inverse.push({ op: "remove", path: operation.path });
+      return;
+    }
+    case "remove": {
+      if (!hasOwn(parent, key)) {
+        onMissingRemove(operation.path);
+        return;
+      }
+      let previous = clonePlain(parent[key]);
+      delete parent[key], undo.push(() => {
+        parent[key] = previous;
+      }), inverse.push({ op: "add", path: operation.path, value: previous });
+      return;
+    }
+    default: {
+      let exhaustive = operation;
+    }
+  }
+}
+
+// src/shared/open-service/service-sync.ts
+var DEFAULT_LOG_MAX_AGE_MS = 15e3, DEFAULT_LOG_MAX_ENTRIES = 256;
+function vectorCounter(vector, runtimeId) {
+  return vector[runtimeId] ?? 0;
+}
+function isEmptyVector(vector) {
+  for (let value of Object.values(vector))
+    if (value > 0)
+      return !1;
+  return !0;
+}
+function vectorDominates(left, right) {
+  if (isEmptyVector(right))
+    return !isEmptyVector(left);
+  let keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]), greater = !1;
+  for (let key of keys) {
+    let leftCount = vectorCounter(left, key), rightCount = vectorCounter(right, key);
+    if (leftCount < rightCount)
+      return !1;
+    leftCount > rightCount && (greater = !0);
+  }
+  return greater;
+}
+function vectorsEqual(left, right) {
+  let keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+  for (let key of keys)
+    if (vectorCounter(left, key) !== vectorCounter(right, key))
+      return !1;
+  return !0;
+}
+function vectorsConcurrent(left, right) {
+  return !vectorDominates(left, right) && !vectorDominates(right, left) && !vectorsEqual(left, right);
+}
+function formatFrontier(frontier) {
+  let body = Object.keys(frontier.vector).sort().map((key) => `${key}:${frontier.vector[key]}`).join(",");
+  return `{clock:${frontier.clock} vector:{${body}}}`;
+}
+function compareStamps(left, right) {
+  return left.seq !== right.seq ? left.seq < right.seq ? -1 : 1 : left.runtimeId !== right.runtimeId ? left.runtimeId < right.runtimeId ? -1 : 1 : 0;
+}
+function applyStatePatch(target, source, options) {
+  mergeInto(target, clonePlain(source), options.preserveMissingKeys);
+}
+function mergeInto(target, source, preserveMissingKeys) {
+  if (!preserveMissingKeys)
+    for (let key of Object.keys(target))
+      hasOwn(source, key) || delete target[key];
+  for (let key of Object.keys(source)) {
+    let sourceValue = source[key], targetValue = target[key];
+    isPlainObject(sourceValue) && isPlainObject(targetValue) ? mergeInto(targetValue, sourceValue, preserveMissingKeys) : targetValue !== sourceValue && (target[key] = sourceValue);
+  }
+}
+function createReconciler(options) {
+  let { serviceId, setState } = options, logWindow = {
+    maxAgeMs: options.window?.maxAgeMs ?? DEFAULT_LOG_MAX_AGE_MS,
+    maxEntries: options.window?.maxEntries ?? DEFAULT_LOG_MAX_ENTRIES
+  }, clock = 0, snapshotSeq = 0, vector = /* @__PURE__ */ new Map(), log = [], logKeys = /* @__PURE__ */ new Set(), dropped = /* @__PURE__ */ new Set(), floor, vectorRecord = () => Object.fromEntries(vector), vectorOf = (runtimeId) => vector.get(runtimeId) ?? 0, hasStamp = (stamp) => logKeys.has(entryStampKey(stamp)), silentMissingRemove = () => {
+  }, patchPaths = (patch) => patch.map((operation) => operation.path).join(","), undoEntry = (current, entry) => {
+    let result = applyJsonPatch(current, entry.inverse, silentMissingRemove);
+    result.ok || logger.warn(
+      `Open-service sync: undo failed. service=${serviceId} stamp=${entryStampKey(entry.stamp)} path=${result.path} command=${entry.command}`
+    );
+  }, redoEntry = (current, entry) => {
+    let result = applyJsonPatch(current, entry.patch, silentMissingRemove);
+    entry.inverse = result.ok ? result.inverse : [], result.ok || logger.warn(
+      `Open-service sync: replay failed. service=${serviceId} stamp=${entryStampKey(entry.stamp)} path=${result.path} command=${entry.command}`
+    );
+  }, undoToIndex = (current, index) => {
+    let undone = [];
+    for (let cursor = log.length - 1; cursor >= index; cursor -= 1) {
+      let entry = log[cursor];
+      undoEntry(current, entry), undone.push(entry);
+    }
+    return undone;
+  }, redoUndone = (current, undone) => {
+    for (let cursor = undone.length - 1; cursor >= 0; cursor -= 1)
+      redoEntry(current, undone[cursor]);
+  }, insertIndexFor = (stamp) => {
+    let index = 0;
+    for (; index < log.length && compareStamps(log[index].stamp, stamp) < 0; )
+      index += 1;
+    return index;
+  }, tryAdvanceVector = (stamp) => {
+    if (stamp.counter !== vectorOf(stamp.runtimeId) + 1)
+      return;
+    let counters = /* @__PURE__ */ new Set();
+    for (let entry of log)
+      entry.stamp.runtimeId === stamp.runtimeId && counters.add(entry.stamp.counter);
+    let next = stamp.counter;
+    for (; counters.has(next + 1); )
+      next += 1;
+    vector.set(stamp.runtimeId, next);
+  }, evict = (now) => {
+    let minKeepIndex = Math.max(0, log.length - logWindow.maxEntries), kept = [];
+    for (let index = 0; index < log.length; index += 1) {
+      let entry = log[index], amongNewest = index >= minKeepIndex, young = now - entry.appliedAt < logWindow.maxAgeMs;
+      amongNewest || young ? kept.push(entry) : (logKeys.delete(entryStampKey(entry.stamp)), (floor === void 0 || compareStamps(entry.stamp, floor) > 0) && (floor = entry.stamp));
+    }
+    kept.length !== log.length && (log.length = 0, log.push(...kept));
+  }, remember = (entry) => {
+    logKeys.add(entryStampKey(entry.stamp)), tryAdvanceVector(entry.stamp), evict(entry.appliedAt);
+  }, appendOrInsert = (entry, index) => {
+    index === log.length ? log.push(entry) : log.splice(index, 0, entry), remember(entry);
+  }, advanceClock = (seq) => {
+    seq > clock && (clock = seq);
+  };
+  return {
+    get clock() {
+      return clock;
+    },
+    get vector() {
+      return vectorRecord();
+    },
+    get frontier() {
+      return { vector: vectorRecord(), clock };
+    },
+    get log() {
+      return log.map(({ stamp, command, patch }) => ({ stamp, command, patch }));
+    },
+    has(stamp) {
+      return hasStamp(stamp);
+    },
+    advanceLocal(runtimeId, authored) {
+      let stamp = {
+        seq: clock + 1,
+        runtimeId,
+        counter: vectorOf(runtimeId) + 1
+      };
+      advanceClock(stamp.seq);
+      let now = Date.now(), entry = {
+        stamp,
+        command: authored.command,
+        patch: [...authored.patch],
+        inverse: [...authored.inverse],
+        appliedAt: now
+      };
+      return appendOrInsert(entry, log.length), stamp;
+    },
+    tryInstall(frontier, state) {
+      advanceClock(frontier.clock);
+      let localVector = vectorRecord();
+      if (!vectorDominates(frontier.vector, localVector))
+        return vectorsConcurrent(frontier.vector, localVector) ? "concurrent" : "not-ahead";
+      snapshotSeq = frontier.clock;
+      let remaining = [];
+      for (let entry of log)
+        if (!(entry.stamp.counter <= vectorCounter(frontier.vector, entry.stamp.runtimeId))) {
+          if (entry.stamp.seq <= frontier.clock) {
+            logger.warn(
+              `Open-service sync: uncovered entry at or below the reply clock dropped on install. service=${serviceId} stamp=${entryStampKey(entry.stamp)} clock=${frontier.clock} paths=${patchPaths(entry.patch)} command=${entry.command}`
+            );
+            continue;
+          }
+          remaining.push(entry);
+        }
+      return setState((current) => {
+        applyStatePatch(current, state, { preserveMissingKeys: !1 }), logKeys.clear(), dropped.clear(), log.length = 0, floor = void 0, vector.clear();
+        for (let [runtimeId, counter] of Object.entries(frontier.vector))
+          counter > 0 && vector.set(runtimeId, counter);
+        for (let entry of remaining) {
+          let replayed = { ...entry };
+          redoEntry(current, replayed), log.push(replayed), remember(replayed);
+        }
+      }), "installed";
+    },
+    tryPlaceEntry(incoming) {
+      let { stamp, command, patch } = incoming, key = entryStampKey(stamp);
+      if (advanceClock(stamp.seq), hasStamp(stamp) || dropped.has(key) || stamp.counter <= vectorOf(stamp.runtimeId))
+        return "duplicate";
+      if (stamp.seq <= snapshotSeq || floor && compareStamps(stamp, floor) <= 0) {
+        let floorLabel = floor ? `,${entryStampKey(floor)}` : "";
+        return logger.warn(
+          `Open-service sync: entry beyond the log window. service=${serviceId} stamps=${key}${floorLabel} paths=${patchPaths(patch)} command=${command}`
+        ), dropped.add(key), "beyond-window";
+      }
+      let gap = stamp.counter > vectorOf(stamp.runtimeId) + 1, index = insertIndexFor(stamp), now = Date.now(), failedPath;
+      return setState((current) => {
+        let inverse = [], undone = index === log.length ? [] : undoToIndex(current, index), result = applyJsonPatch(current, patch, (path) => {
+          logger.debug(
+            `Open-service sync: remove of missing key. service=${serviceId} stamp=${key} path=${path} command=${command}`
+          );
+        });
+        result.ok ? inverse = result.inverse : failedPath = result.path, redoUndone(current, undone), appendOrInsert({ stamp, command, patch: [...patch], inverse, appliedAt: now }, index);
+      }), failedPath !== void 0 && logger.warn(
+        `Open-service sync: entry did not apply, kept as a no-op. service=${serviceId} stamp=${key} path=${failedPath} command=${command}`
+      ), gap && logger.warn(
+        `Open-service sync: gap in writer counters. service=${serviceId} stamps=${key} paths=${patchPaths(patch)} command=${command}`
+      ), gap ? "gap" : failedPath !== void 0 ? "unapplied" : "accepted";
+    }
+  };
+}
+
+// src/shared/open-service/service-runtime.ts
+function normalizeStaticStoragePath(serviceId, name, rawPath) {
+  let segments = rawPath.replaceAll("\\", "/").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+  if (segments.length === 0 || segments.some((segment) => segment === ".."))
+    throw new OpenServiceInvalidStaticPathError({ serviceId, name, path: rawPath });
+  return segments.join("/");
+}
+function resolveStaticPath(serviceId, name, queryDef, input) {
+  let rawPath = queryDef.staticPath(input), relativePath = normalizeStaticStoragePath(serviceId, name, rawPath);
+  return `${serviceId}/${relativePath}`;
+}
+function buildCommands(serviceId, commands, createCommandCtx) {
+  return Object.fromEntries(
+    Object.entries(commands).map(([name, def]) => [
+      name,
+      async (input) => {
+        if (!def.handler)
+          throw new OpenServiceUnimplementedOperationError({
+            kind: "command",
+            serviceId,
+            name
+          });
+        let validatedInput = await validateSchema(def.input, input, {
+          kind: "command",
+          serviceId,
+          name,
+          phase: "input"
+        }), output = await def.handler(validatedInput, createCommandCtx(name));
+        return validateSchema(def.output, output, {
+          kind: "command",
+          serviceId,
+          name,
+          phase: "output"
+        });
+      }
+    ])
+  );
+}
+function buildQueryDefinitionsWithStaticLoader(serviceId, queries, staticLoader, applyLocal) {
+  return new Map(
+    Object.entries(queries).map(([name, queryDef]) => {
+      if (!queryDef.staticPath)
+        return [name, queryDef];
+      let { staticPath } = queryDef;
+      return [
+        name,
+        {
+          ...queryDef,
+          load: async (input) => {
+            let logicalPath = resolveStaticPath(serviceId, name, { staticPath }, input), snapshot = await staticLoader(logicalPath, {
+              serviceId,
+              queryName: name,
+              input
+            });
+            applyLocal((state) => {
+              applyStatePatch(state, snapshot, {
+                preserveMissingKeys: !0
+              });
+            });
+          }
+        }
+      ];
+    })
+  );
+}
+function createServiceRuntime(def, runtimeOptions, initialState = def.initialState) {
+  let rawState = clonePlain(initialState), state = u2(rawState), getStateSnapshot = () => structuredClone(rawState), { registryApi, staticLoader } = runtimeOptions, author = () => {
+  }, applyLocal = (mutate) => {
+    n(() => {
+      mutate(state);
+    });
+  }, writeState = (command, mutate) => {
+    recordPatch(
+      state,
+      mutate,
+      (recorded) => author({ command, ...recorded })
+    );
+  }, defaultQueries = {}, reactiveLoadQueries = {}, createCommandSelf = (setState, commandsForSelf) => ({
+    get state() {
+      return state;
+    },
+    setState,
+    queries: defaultQueries,
+    get commands() {
+      return commandsForSelf();
+    }
+  }), commands = buildCommands(def.id, def.commands, (commandName) => ({
+    self: createCommandSelf(
+      (mutate) => writeState(commandName, mutate),
+      () => commands
+    ),
+    getService: registryApi.getService
+  })), loadCommands = commands, remoteCommandNames = /* @__PURE__ */ new Set(), queryDefinitions = staticLoader ? buildQueryDefinitionsWithStaticLoader(
+    def.id,
+    def.queries,
+    staticLoader,
+    applyLocal
+  ) : new Map(
+    Object.entries(def.queries)
+  ), buildGatedCommands = (isCurrent) => {
+    let gated = buildCommands(
+      def.id,
+      def.commands,
+      (commandName) => ({
+        self: createCommandSelf(
+          (mutate) => {
+            isCurrent() && writeState(commandName, mutate);
+          },
+          () => gated
+        ),
+        getService: registryApi.getService
+      })
+    );
+    return remoteCommandNames.size === 0 ? gated : Object.fromEntries(
+      Object.keys(def.commands).map((name) => [
+        name,
+        remoteCommandNames.has(name) ? loadCommands[name] : gated[name]
+      ])
+    );
+  }, loadScopeId = nextLoadScopeId(), refs = {
+    serviceId: def.id,
+    loadScopeId,
+    state,
+    registryApi,
+    queryDefinitions,
+    defaultQueries,
+    reactiveLoadQueries,
+    getLoadCommands: () => loadCommands,
+    buildGatedCommands
+  }, builtQueries = buildQueries(refs);
+  for (let [name, query] of Object.entries(builtQueries))
+    defaultQueries[name] = query;
+  for (let [name, query] of Object.entries(buildReactiveLoadQueries(refs)))
+    reactiveLoadQueries[name] = query;
+  let queries = defaultQueries, queryCtx = { self: {
+    get state() {
+      return state;
+    },
+    queries: defaultQueries
+  }, getService: registryApi.getService }, loadCtxForStatic = {
+    self: {
+      get state() {
+        return state;
+      },
+      queries: defaultQueries,
+      commands
+    },
+    getService: registryApi.getService
+  };
+  return {
+    getStateSnapshot,
+    applyLocal,
+    attachEntryAuthor: (next) => {
+      author = next;
+    },
+    queryCtx,
+    loadCtxForStatic,
+    commands,
+    queries,
+    runLoadOnce: async (queryName, validatedInput) => {
+      let queryDef = queryDefinitions.get(queryName);
+      if (!queryDef || !queryDef.load)
+        return;
+      let loadKey = makeLoadKey(def.id, queryName, validatedInput), ancestorChain = /* @__PURE__ */ new Set([loadKey]), inFlightKey = makeInFlightKey(loadScopeId, loadKey), promise = Promise.resolve().then(() => runLoadBody(refs, queryName, queryDef, validatedInput, ancestorChain)).finally(() => {
+        inFlightLoads.get(inFlightKey) === promise && inFlightLoads.delete(inFlightKey);
+      });
+      inFlightLoads.set(inFlightKey, promise), await promise;
+    },
+    attachChannelCommands: (channelCommands, implementedCommandNames) => {
+      loadCommands = channelCommands, remoteCommandNames.clear();
+      for (let name of Object.keys(def.commands))
+        implementedCommandNames.has(name) || remoteCommandNames.add(name);
+    }
+  };
+}
+
+// src/shared/open-service/service-transport.ts
+import * as v4 from "valibot";
+import { logger as logger2 } from "@aussieljk/forkbook/internal/client-logger";
+var REMOTE_COMMAND_ACK_TIMEOUT_MS = 300, SYNC_REQUEST_SILENCE_MS = 1e3;
+function createEntryAuthor(context) {
+  let { serviceId, ownRuntimeId, reconciler, channel: channel2 } = context;
+  return ({ command, ops, inverse }) => {
+    let stamp = reconciler.advanceLocal(ownRuntimeId, { command, patch: ops, inverse });
+    channel2.emit(SERVICE_ENTRY, {
+      serviceId,
+      stamp,
+      command,
+      patch: ops
+    });
+  };
+}
+function connectRuntimeToChannel(context) {
+  let { serviceId, ownRuntimeId, reconciler, getSnapshot, channel: channel2, relay } = context, requestOutstanding = !1, withinReplyWindow = !1, repairQueued = !1, silenceTimer, forwardedReplyKey, clearSilenceTimer = () => {
+    silenceTimer !== void 0 && (clearTimeout(silenceTimer), silenceTimer = void 0);
+  }, emitSyncRequest = () => {
+    if (requestOutstanding) {
+      repairQueued = !0;
+      return;
+    }
+    requestOutstanding = !0, withinReplyWindow = !0, repairQueued = !1, channel2.emit(SERVICE_SYNC_REQUEST, {
+      serviceId,
+      runtimeId: ownRuntimeId,
+      frontier: reconciler.frontier
+    }), clearSilenceTimer(), silenceTimer = setTimeout(() => {
+      silenceTimer = void 0, withinReplyWindow = !1, settleOutstandingRequest();
+    }, SYNC_REQUEST_SILENCE_MS);
+  }, settleOutstandingRequest = () => {
+    let queued = repairQueued;
+    requestOutstanding = !1, queued && emitSyncRequest();
+  }, onSyncRequest = (payload) => {
+    let request = v4.safeParse(syncRequestSchema, payload);
+    !request.success || request.output.serviceId !== serviceId || request.output.runtimeId === ownRuntimeId || vectorDominates(reconciler.vector, request.output.frontier.vector) && channel2.emit(SERVICE_SYNC_REPLY, {
+      serviceId,
+      runtimeId: ownRuntimeId,
+      frontier: reconciler.frontier,
+      state: getSnapshot()
+    });
+  }, onSyncReply = (payload) => {
+    let snapshot = v4.safeParse(syncReplySchema, payload);
+    if (!snapshot.success || snapshot.output.serviceId !== serviceId || snapshot.output.runtimeId === ownRuntimeId)
+      return;
+    let replyKey = `${snapshot.output.runtimeId}:${formatFrontier(snapshot.output.frontier)}`;
+    if (replyKey === forwardedReplyKey)
+      return;
+    let outcome;
+    try {
+      outcome = reconciler.tryInstall(snapshot.output.frontier, snapshot.output.state);
+    } finally {
+      let settled = outcome ?? "installed";
+      settled === "concurrent" && withinReplyWindow && (logger2.warn(
+        `Open-service sync: concurrent snapshot reply dropped. service=${serviceId} local=${formatFrontier(reconciler.frontier)} reply=${formatFrontier(snapshot.output.frontier)}`
+      ), repairQueued = !0), settleOutstandingRequest(), settled === "installed" && relay && (forwardedReplyKey = replyKey, channel2.emit(SERVICE_SYNC_REPLY, payload));
+    }
+  }, onEntry = (payload) => {
+    let parsed = v4.safeParse(entrySchema, payload);
+    if (!parsed.success || parsed.output.serviceId !== serviceId)
+      return;
+    let outcome;
+    try {
+      outcome = reconciler.tryPlaceEntry(parsed.output);
+    } finally {
+      let placed = outcome ?? (reconciler.has(parsed.output.stamp) ? "unapplied" : void 0), logged = placed === "accepted" || placed === "gap" || placed === "unapplied", needsRepair = placed === "gap" || placed === "beyond-window" || placed === "unapplied";
+      (logged || placed === "beyond-window") && relay && channel2.emit(SERVICE_ENTRY, payload), needsRepair && emitSyncRequest();
+    }
+  };
+  return channel2.on(SERVICE_SYNC_REQUEST, onSyncRequest), channel2.on(SERVICE_SYNC_REPLY, onSyncReply), channel2.on(SERVICE_ENTRY, onEntry), emitSyncRequest(), () => {
+    channel2.off(SERVICE_SYNC_REQUEST, onSyncRequest), channel2.off(SERVICE_SYNC_REPLY, onSyncReply), channel2.off(SERVICE_ENTRY, onEntry), repairQueued = !1, requestOutstanding = !1, withinReplyWindow = !1, clearSilenceTimer();
+  };
+}
+function connectCommandTransport(context) {
+  let {
+    serviceId,
+    ownRuntimeId,
+    channel: channel2,
+    localCommands,
+    implementedCommandNames,
+    commandNames,
+    delegated
+  } = context, dispatchesLocally = (commandName) => !delegated && implementedCommandNames.has(commandName), pending = /* @__PURE__ */ new Map(), settle = (callId, apply) => {
+    let entry = pending.get(callId);
+    entry && (pending.delete(callId), clearTimeout(entry.noAckTimer), apply(entry));
+  }, onInvoke = (payload) => {
+    let parsed = v4.safeParse(commandInvokeSchema, payload);
+    if (!parsed.success || parsed.output.serviceId !== serviceId)
+      return;
+    let invoke = parsed.output;
+    if (!dispatchesLocally(invoke.commandName)) {
+      !delegated && invoke.runtimeId !== ownRuntimeId && channel2.emit(SERVICE_COMMAND_UNHANDLED, {
+        serviceId,
+        callId: invoke.callId
+      });
+      return;
+    }
+    channel2.emit(SERVICE_COMMAND_ACK, {
+      serviceId,
+      callId: invoke.callId,
+      runtimeId: ownRuntimeId
+    }), setTimeout(() => {
+      Promise.resolve().then(() => localCommands[invoke.commandName](invoke.input)).then(
+        (result) => {
+          channel2.emit(SERVICE_COMMAND_RESULT, {
+            serviceId,
+            callId: invoke.callId,
+            result,
+            runtimeId: ownRuntimeId
+          });
+        },
+        (error) => {
+          channel2.emit(SERVICE_COMMAND_ERROR, {
+            serviceId,
+            callId: invoke.callId,
+            error: serializeError(error),
+            runtimeId: ownRuntimeId
+          });
+        }
+      );
+    }, 0);
+  }, onResult = (payload) => {
+    let result = v4.safeParse(commandResultSchema, payload);
+    !result.success || result.output.serviceId !== serviceId || settle(result.output.callId, (entry) => entry.resolve(result.output.result));
+  }, onError = (payload) => {
+    let failure = v4.safeParse(commandErrorSchema, payload);
+    !failure.success || failure.output.serviceId !== serviceId || settle(failure.output.callId, (entry) => entry.reject(deserializeError(failure.output.error)));
+  }, onAck = (payload) => {
+    let ack = v4.safeParse(commandAckSchema, payload);
+    if (!ack.success || ack.output.serviceId !== serviceId)
+      return;
+    let entry = pending.get(ack.output.callId);
+    entry && clearTimeout(entry.noAckTimer);
+  }, onUnhandled = (payload) => {
+    let report = v4.safeParse(commandUnhandledSchema, payload);
+    !report.success || report.output.serviceId !== serviceId || !delegated || settle(
+      report.output.callId,
+      (entry) => entry.reject(
+        new OpenServiceRemoteCommandConfigDriftError({
+          serviceId,
+          commandName: entry.commandName
+        })
+      )
+    );
+  };
+  channel2.on(SERVICE_COMMAND_INVOKE, onInvoke), channel2.on(SERVICE_COMMAND_RESULT, onResult), channel2.on(SERVICE_COMMAND_ERROR, onError), channel2.on(SERVICE_COMMAND_ACK, onAck), channel2.on(SERVICE_COMMAND_UNHANDLED, onUnhandled);
+  let requestRemote = (commandName, input) => {
+    let callId = generateCallId();
+    return new Promise((resolve, reject) => {
+      let noAckTimer = setTimeout(() => {
+        settle(
+          callId,
+          (entry) => entry.reject(
+            new OpenServiceRemoteCommandUnhandledError({
+              serviceId,
+              commandName: entry.commandName,
+              delegated
+            })
+          )
+        );
+      }, REMOTE_COMMAND_ACK_TIMEOUT_MS);
+      pending.set(callId, { commandName, resolve, reject, noAckTimer }), channel2.emit(SERVICE_COMMAND_INVOKE, {
+        serviceId,
+        commandName,
+        input,
+        callId,
+        runtimeId: ownRuntimeId
+      });
+    });
+  }, commands = {};
+  for (let name of commandNames)
+    commands[name] = dispatchesLocally(name) ? localCommands[name] : (input) => requestRemote(name, input);
+  return {
+    commands,
+    disconnect: () => {
+      channel2.off(SERVICE_COMMAND_INVOKE, onInvoke), channel2.off(SERVICE_COMMAND_RESULT, onResult), channel2.off(SERVICE_COMMAND_ERROR, onError), channel2.off(SERVICE_COMMAND_ACK, onAck), channel2.off(SERVICE_COMMAND_UNHANDLED, onUnhandled);
+      for (let [, entry] of pending)
+        clearTimeout(entry.noAckTimer), entry.reject(new OpenServiceRemoteCommandDisconnectedError({ serviceId }));
+      pending.clear();
+    }
+  };
+}
+function connectUnknownServiceReporter(context) {
+  let { channel: channel2, isServiceRegistered, isDelegated } = context, onInvoke = (payload) => {
+    let parsed = v4.safeParse(commandInvokeSchema, payload);
+    !parsed.success || isDelegated() || isServiceRegistered(parsed.output.serviceId) || channel2.emit(SERVICE_COMMAND_UNHANDLED, {
+      serviceId: parsed.output.serviceId,
+      callId: parsed.output.callId
+    });
+  };
+  return channel2.on(SERVICE_COMMAND_INVOKE, onInvoke), () => {
+    channel2.off(SERVICE_COMMAND_INVOKE, onInvoke);
+  };
+}
+function connectServiceToChannel(context) {
+  let {
+    serviceId,
+    ownRuntimeId,
+    reconciler,
+    getSnapshot,
+    channel: channel2,
+    relay,
+    commands,
+    implementedCommandNames,
+    commandNames,
+    delegated,
+    runtime
+  } = context;
+  runtime.attachEntryAuthor(createEntryAuthor({ serviceId, ownRuntimeId, reconciler, channel: channel2 }));
+  let commandTransport = connectCommandTransport({
+    serviceId,
+    ownRuntimeId,
+    channel: channel2,
+    localCommands: commands,
+    implementedCommandNames,
+    commandNames,
+    delegated
+  }), disconnectSync = connectRuntimeToChannel({
+    serviceId,
+    ownRuntimeId,
+    reconciler,
+    getSnapshot,
+    channel: channel2,
+    relay
+  });
+  return runtime.attachChannelCommands(
+    commandTransport.commands,
+    delegated ? /* @__PURE__ */ new Set() : implementedCommandNames
+  ), {
+    commands: commandTransport.commands,
+    disconnect: () => {
+      disconnectSync(), commandTransport.disconnect();
+    }
+  };
+}
+
+// src/shared/open-service/service-registry.ts
+var REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("storybook.open-service.registry");
+function getInventory() {
+  let registryGlobal = globalThis;
+  return registryGlobal[REGISTRY_SYMBOL] ??= {
+    entries: /* @__PURE__ */ new Map(),
+    delegatedMode: !1,
+    everRegisteredIds: /* @__PURE__ */ new Set()
+  }, registryGlobal[REGISTRY_SYMBOL];
+}
+function getRegistry() {
+  return getInventory().entries;
+}
+function setDelegatedMode(enabled) {
+  getInventory().delegatedMode = enabled;
+}
+function isDelegatedMode() {
+  return getInventory().delegatedMode;
+}
+function ensureUnknownServiceReporter(channel2) {
+  let inventory = getInventory();
+  inventory.unknownServiceReporter?.channel !== channel2 && (inventory.unknownServiceReporter?.disconnect(), inventory.unknownServiceReporter = {
+    channel: channel2,
+    disconnect: connectUnknownServiceReporter({
+      channel: channel2,
+      isServiceRegistered: (serviceId) => inventory.everRegisteredIds.has(serviceId),
+      isDelegated: () => inventory.delegatedMode
+    })
+  });
+}
+function assertUniqueOperationNames(definition) {
+  let duplicateName = Object.keys(definition.queries).find(
+    (name) => Object.hasOwn(definition.commands, name)
+  );
+  if (duplicateName)
+    throw new OpenServiceOperationNameCollisionError({
+      serviceId: definition.id,
+      operationName: duplicateName
+    });
+}
+function describeDefinition(definition) {
+  return {
+    id: definition.id,
+    description: definition.description,
+    queries: Object.fromEntries(
+      Object.entries(definition.queries).filter(([, query]) => !query.internal).map(([name, query]) => [
+        name,
+        {
+          name,
+          description: query.description,
+          input: query.input,
+          output: query.output,
+          ...query.staticPath ? { staticPath: !0 } : {}
+        }
+      ])
+    ),
+    commands: Object.fromEntries(
+      Object.entries(definition.commands).filter(([, command]) => !command.internal).map(([name, command]) => [
+        name,
+        {
+          name,
+          description: command.description,
+          input: command.input,
+          output: command.output
+        }
+      ])
+    )
+  };
+}
+function summarizeDescriptor(descriptor) {
+  return {
+    id: descriptor.id,
+    description: descriptor.description,
+    queryNames: Object.keys(descriptor.queries),
+    commandNames: Object.keys(descriptor.commands)
+  };
+}
+function applyRegistration(definition, registration) {
+  return registration ? {
+    ...definition,
+    queries: Object.fromEntries(
+      Object.entries(definition.queries).map(([name, query]) => {
+        let override = registration.queries?.[name];
+        return [
+          name,
+          override && "staticInputs" in override ? { ...query, staticInputs: override.staticInputs } : query
+        ];
+      })
+    ),
+    commands: Object.fromEntries(
+      Object.entries(definition.commands).map(([name, command]) => {
+        let override = registration.commands?.[name];
+        return [
+          name,
+          override && "handler" in override ? { ...command, handler: override.handler } : command
+        ];
+      })
+    )
+  } : definition;
+}
+var serviceRegistryApi = {
+  listServices,
+  describeService,
+  getService
+};
+function registerService(definition, registration, { relay = !1, staticLoader, window: window2 } = {}) {
+  assertUniqueOperationNames(definition);
+  let registry = getRegistry(), existingEntry = registry.get(definition.id);
+  if (existingEntry)
+    return existingEntry.instance;
+  let ownRuntimeId = generateRuntimeId(), resolvedDefinition = applyRegistration(definition, registration), runtime = createServiceRuntime(resolvedDefinition, {
+    registryApi: serviceRegistryApi,
+    staticLoader
+  }), reconciler = createReconciler({
+    serviceId: definition.id,
+    setState: (mutate) => runtime.applyLocal((state) => mutate(state)),
+    window: window2
+  }), getSnapshot = () => runtime.getStateSnapshot(), descriptor = describeDefinition(resolvedDefinition), channel2 = getChannel();
+  if (!channel2)
+    throw new OpenServiceMissingChannelError({ serviceId: definition.id });
+  getInventory().everRegisteredIds.add(definition.id), ensureUnknownServiceReporter(channel2);
+  let implementedCommandNames = new Set(
+    Object.entries(resolvedDefinition.commands).filter(([, command]) => typeof command.handler == "function").map(([name]) => name)
+  ), { commands, disconnect } = connectServiceToChannel({
+    serviceId: definition.id,
+    ownRuntimeId,
+    reconciler,
+    getSnapshot,
+    channel: channel2,
+    relay: isDelegatedMode() ? !1 : relay,
+    commands: runtime.commands,
+    implementedCommandNames,
+    commandNames: Object.keys(resolvedDefinition.commands),
+    delegated: isDelegatedMode(),
+    runtime
+  }), instance = {
+    queries: runtime.queries,
+    commands,
+    ...serviceRegistryApi
+  };
+  return registry.set(definition.id, {
+    definition: resolvedDefinition,
+    instance,
+    descriptor,
+    summary: summarizeDescriptor(descriptor),
+    disconnect
+  }), instance;
+}
+function getRegisteredServices() {
+  return Array.from(getRegistry().values(), ({ definition }) => definition);
+}
+async function listServices() {
+  return Array.from(getRegistry().values()).filter(({ definition }) => !definition.internal).map(({ summary }) => summary);
+}
+async function describeService(serviceId) {
+  let entry = getRegistry().get(serviceId);
+  if (!entry)
+    throw new OpenServiceMissingServiceError({ serviceId });
+  return entry.descriptor;
+}
+function getService(serviceId, options) {
+  let entry = getRegistry().get(serviceId);
+  if (!entry)
+    throw new OpenServiceMissingServiceError({ serviceId });
+  if (entry.definition.internal && !options?.internal)
+    throw new OpenServiceInternalServiceError({ serviceId });
+  return entry.instance;
+}
+function clearRegistry() {
+  let inventory = getInventory();
+  for (let entry of inventory.entries.values())
+    entry.disconnect();
+  inventory.entries.clear(), inventory.delegatedMode = !1, inventory.everRegisteredIds.clear(), inventory.unknownServiceReporter?.disconnect(), inventory.unknownServiceReporter = void 0;
+}
+
+export {
+  Channel,
+  getChannel,
+  setChannel,
+  validateSchema,
+  resolveStaticPath,
+  createServiceRuntime,
+  setDelegatedMode,
+  serviceRegistryApi,
+  registerService,
+  getRegisteredServices,
+  listServices,
+  describeService,
+  getService,
+  clearRegistry
+};