@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_browser-chunks/chunk-YTIT5NA5.js

@@ -0,0 +1,1966 @@
+import {
+  getChannel
+} from "./chunk-OD6IBQCC.js";
+import {
+  buildQueryState,
+  toError
+} from "./chunk-QC4HFS6K.js";
+import {
+  OpenServiceAsyncRecipeError,
+  OpenServiceAsyncSchemaError,
+  OpenServiceCyclicStateError,
+  OpenServiceInternalServiceError,
+  OpenServiceInvalidStaticPathError,
+  OpenServiceLoadedDrainExceededError,
+  OpenServiceMissingChannelError,
+  OpenServiceMissingServiceError,
+  OpenServiceOperationNameCollisionError,
+  OpenServiceRemoteCommandConfigDriftError,
+  OpenServiceRemoteCommandDisconnectedError,
+  OpenServiceRemoteCommandUnhandledError,
+  OpenServiceUnimplementedOperationError,
+  OpenServiceValidationError
+} from "./chunk-6SXYJQST.js";
+import {
+  isEqual
+} from "./chunk-B4AUNNU4.js";
+import {
+  OpenServiceStaticSnapshotInvalidError,
+  OpenServiceStaticSnapshotLoadError
+} from "./chunk-RSPAQWVJ.js";
+
+// ../../node_modules/nanoid/index.browser.js
+var nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => (byte &= 63, byte < 36 ? id += byte.toString(36) : byte < 62 ? id += (byte - 26).toString(36).toUpperCase() : byte > 62 ? id += "-" : id += "_", id), "");
+
+// 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.module.js
+var i = /* @__PURE__ */ Symbol.for("preact-signals");
+function t() {
+  if (v2 > 1)
+    v2--;
+  else {
+    var i3, t2 = !1;
+    for ((function() {
+      var i4 = c;
+      for (c = void 0; i4 !== void 0; ) {
+        var t3 = i4.S;
+        if (t3.v === i4.v) for (var n4 = t3.t; n4 !== void 0; n4 = n4.x) n4.i === i4.i && (n4.i = t3.i);
+        i4 = i4.o;
+      }
+    })(); h !== void 0; ) {
+      var n3 = h;
+      for (h = void 0, s++; n3 !== void 0; ) {
+        var r2 = 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 = r2;
+      }
+    }
+    if (s = 0, v2--, t2) throw i3;
+  }
+}
+function n(i3) {
+  if (v2 > 0) return i3();
+  e = ++u, v2++;
+  try {
+    return i3();
+  } finally {
+    t();
+  }
+}
+var r, o = void 0;
+function f(i3) {
+  var t2 = o, n3 = r;
+  o = void 0, r = void 0;
+  try {
+    return i3();
+  } finally {
+    o = t2, r = n3;
+  }
+}
+var h = void 0, v2 = 0, s = 0, u = 0, e = 0, c = void 0, d = 0;
+function a(i3) {
+  if (o !== void 0) {
+    var 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 l(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;
+}
+l.prototype.brand = i;
+l.prototype.h = function() {
+  return !0;
+};
+l.prototype.S = function(i3) {
+  var t2 = this, n3 = this.t;
+  n3 !== i3 && i3.e === void 0 && (i3.x = n3, this.t = i3, n3 !== void 0 ? n3.e = i3 : f(function() {
+    var i4;
+    (i4 = t2.W) == null || i4.call(t2);
+  }));
+};
+l.prototype.U = function(i3) {
+  var t2 = this;
+  if (this.t !== void 0) {
+    var n3 = i3.e, r2 = i3.x;
+    n3 !== void 0 && (n3.x = r2, i3.e = void 0), r2 !== void 0 && (r2.e = n3, i3.x = void 0), i3 === this.t && (this.t = r2, r2 === void 0 && f(function() {
+      var i4;
+      (i4 = t2.Z) == null || i4.call(t2);
+    }));
+  }
+};
+l.prototype.subscribe = function(i3) {
+  var t2 = this;
+  return j(function() {
+    var n3 = t2.value;
+    f(function() {
+      return i3(n3);
+    });
+  }, { name: "sub" });
+};
+l.prototype.valueOf = function() {
+  return this.value;
+};
+l.prototype.toString = function() {
+  return this.value + "";
+};
+l.prototype.toJSON = function() {
+  return this.value;
+};
+l.prototype.peek = function() {
+  var i3 = this;
+  return f(function() {
+    return i3.value;
+  });
+};
+Object.defineProperty(l.prototype, "value", { get: function() {
+  var i3 = a(this);
+  return i3 !== void 0 && (i3.i = this.i), this.v;
+}, set: function(i3) {
+  if (i3 !== this.v) {
+    if (s > 100) throw new Error("Cycle detected");
+    (function(i4) {
+      v2 !== 0 && s === 0 && i4.l !== e && (i4.l = e, c = { S: i4, v: i4.v, i: i4.i, o: c });
+    })(this), this.v = i3, this.i++, d++, v2++;
+    try {
+      for (var n3 = this.t; n3 !== void 0; n3 = n3.x) n3.t.N();
+    } finally {
+      t();
+    }
+  }
+} });
+function y(i3, t2) {
+  return new l(i3, t2);
+}
+function w(i3) {
+  for (var 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 (var t2 = i3.s; t2 !== void 0; t2 = t2.n) {
+    var 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) {
+  for (var t2 = i3.s, n3 = void 0; t2 !== void 0; ) {
+    var r2 = t2.p;
+    t2.i === -1 ? (t2.S.U(t2), r2 !== void 0 && (r2.n = t2.n), t2.n !== void 0 && (t2.n.p = r2)) : n3 = t2, t2.S.n = t2.r, t2.r !== void 0 && (t2.r = void 0), t2 = r2;
+  }
+  i3.s = n3;
+}
+function p(i3, t2) {
+  l.call(this, void 0, t2), this.x = i3, this.s = void 0, this.g = d - 1, this.f = 4;
+}
+p.prototype = new l();
+p.prototype.h = function() {
+  if (this.f &= -3, 1 & this.f) return !1;
+  if ((36 & this.f) == 32 || (this.f &= -5, this.g === d)) return !0;
+  if (this.g = d, this.f |= 1, this.i > 0 && !w(this))
+    return this.f &= -2, !0;
+  var i3 = o;
+  try {
+    _(this), o = this;
+    var t2 = this.x();
+    (16 & this.f || this.v !== t2 || this.i === 0) && (this.v = t2, 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 (var t2 = this.s; t2 !== void 0; t2 = t2.n) t2.S.S(t2);
+  }
+  l.prototype.S.call(this, i3);
+};
+p.prototype.U = function(i3) {
+  if (this.t !== void 0 && (l.prototype.U.call(this, i3), this.t === void 0)) {
+    this.f &= -33;
+    for (var t2 = this.s; t2 !== void 0; t2 = t2.n) t2.S.U(t2);
+  }
+};
+p.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var i3 = this.t; i3 !== void 0; i3 = i3.x) i3.t.N();
+  }
+};
+Object.defineProperty(p.prototype, "value", { get: function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  var i3 = a(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) {
+  var n3 = i3.m;
+  if (i3.m = void 0, typeof n3 == "function") {
+    v2++;
+    var r2 = o;
+    o = void 0;
+    try {
+      n3();
+    } catch (t2) {
+      throw i3.f &= -2, i3.f |= 8, m(i3), t2;
+    } finally {
+      o = r2, t();
+    }
+  }
+}
+function m(i3) {
+  for (var 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, r && r.push(this);
+}
+E.prototype.c = function() {
+  var i3 = this.S();
+  try {
+    if (8 & this.f || this.x === void 0) return;
+    var 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), v2++;
+  var 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) {
+  var n3 = new E(i3, t2);
+  try {
+    n3.c();
+  } catch (i4) {
+    throw n3.d(), i4;
+  }
+  var r2 = n3.d.bind(n3);
+  return r2[Symbol.dispose] = r2, r2;
+}
+
+// ../../node_modules/deepsignal/core/dist/deepsignal-core.module.js
+var n2 = /* @__PURE__ */ new WeakMap(), a2 = /* @__PURE__ */ new WeakMap(), o2 = /* @__PURE__ */ new WeakMap(), s2 = /* @__PURE__ */ new WeakSet(), u2 = /* @__PURE__ */ new WeakMap(), f2 = /^\$/, c2 = Object.getOwnPropertyDescriptor, i2 = !1, l2 = function(e2) {
+  if (!R(e2)) throw new Error("This object can't be observed.");
+  return a2.has(e2) || a2.set(e2, p2(e2, w2)), a2.get(e2);
+}, g2 = function(e2, t2) {
+  i2 = !0;
+  var r2 = e2[t2];
+  try {
+    i2 = !1;
+  } catch {
+  }
+  return r2;
+};
+var p2 = function(e2, t2) {
+  var r2 = new Proxy(e2, t2);
+  return s2.add(r2), r2;
+}, v3 = function() {
+  throw new Error("Don't mutate the signals directly.");
+}, y2 = function(e2) {
+  return function(s3, u3, l3) {
+    var g3;
+    if (i2) return Reflect.get(s3, u3, l3);
+    var h2 = e2 || u3[0] === "$";
+    if (!e2 && h2 && Array.isArray(s3)) {
+      if (u3 === "$") return o2.has(s3) || o2.set(s3, p2(s3, d2)), o2.get(s3);
+      h2 = u3 === "$length";
+    }
+    n2.has(l3) || n2.set(l3, /* @__PURE__ */ new Map());
+    var v5 = n2.get(l3), y3 = h2 ? u3.replace(f2, "") : u3;
+    if (v5.has(y3) || typeof ((g3 = c2(s3, y3)) == null ? void 0 : g3.get) != "function") {
+      var m3 = Reflect.get(s3, y3, l3);
+      if (h2 && typeof m3 == "function") return;
+      if (typeof y3 == "symbol" && b2.has(y3)) return m3;
+      v5.has(y3) || (R(m3) && (a2.has(m3) || a2.set(m3, p2(m3, w2)), m3 = a2.get(m3)), v5.set(y3, y(m3)));
+    } else v5.set(y3, g(function() {
+      return Reflect.get(s3, y3, l3);
+    }));
+    return h2 ? v5.get(y3) : v5.get(y3).value;
+  };
+}, w2 = { get: y2(!1), set: function(r2, o3, s3, i3) {
+  var l3;
+  if (typeof ((l3 = c2(r2, o3)) == null ? void 0 : l3.set) == "function") return Reflect.set(r2, o3, s3, i3);
+  n2.has(i3) || n2.set(i3, /* @__PURE__ */ new Map());
+  var g3 = n2.get(i3);
+  if (o3[0] === "$") {
+    s3 instanceof l || v3();
+    var h2 = o3.replace(f2, "");
+    return g3.set(h2, s3), Reflect.set(r2, h2, s3.peek(), i3);
+  }
+  var y3 = s3;
+  R(s3) && (a2.has(s3) || a2.set(s3, p2(s3, w2)), y3 = a2.get(s3));
+  var d3 = !(o3 in r2), b3 = Reflect.set(r2, o3, s3, i3);
+  return g3.has(o3) ? g3.get(o3).value = y3 : g3.set(o3, y(y3)), d3 && u2.has(r2) && u2.get(r2).value++, Array.isArray(r2) && g3.has("length") && (g3.get("length").value = r2.length), b3;
+}, deleteProperty: function(e2, t2) {
+  t2[0] === "$" && v3();
+  var r2 = n2.get(a2.get(e2)), o3 = Reflect.deleteProperty(e2, t2);
+  return r2 && r2.has(t2) && (r2.get(t2).value = void 0), u2.has(e2) && u2.get(e2).value++, o3;
+}, ownKeys: function(e2) {
+  return u2.has(e2) || u2.set(e2, y(0)), u2._ = u2.get(e2).value, Reflect.ownKeys(e2);
+} }, d2 = { get: y2(!0), set: v3, deleteProperty: v3 }, b2 = new Set(Object.getOwnPropertyNames(Symbol).map(function(e2) {
+  return Symbol[e2];
+}).filter(function(e2) {
+  return typeof e2 == "symbol";
+})), m2 = /* @__PURE__ */ new Set([Object, Array]), R = function(e2) {
+  return typeof e2 == "object" && e2 !== null && m2.has(e2.constructor) && !s2.has(e2);
+};
+
+// src/shared/open-service/patch-recorder.ts
+function peekProp(obj, key) {
+  return g2(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(() => {
+    f(() => {
+      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/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 = f(() => 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 = f(() => 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 = l2(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";
+
+// src/shared/open-service/service-error-serialization.ts
+var ERROR_MARKER = "__openServiceError__", RESERVED_KEYS = /* @__PURE__ */ new Set([ERROR_MARKER, "name", "message", "stack", "cause"]);
+function isPlainObject2(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function isSerializedError(value) {
+  return isPlainObject2(value) && value[ERROR_MARKER] === !0;
+}
+function toTransportSafe(value) {
+  if (value instanceof Error)
+    return serializeError(value);
+  if (Array.isArray(value))
+    return value.map((entry) => toTransportSafe(entry));
+  if (isPlainObject2(value)) {
+    let result = {};
+    for (let [key, entry] of Object.entries(value))
+      result[key] = toTransportSafe(entry);
+    return result;
+  }
+  if (value === null)
+    return null;
+  let kind = typeof value;
+  if (kind === "string" || kind === "number" || kind === "boolean")
+    return value;
+  if (kind === "bigint")
+    return value.toString();
+}
+function serializeError(value) {
+  if (!(value instanceof Error))
+    return { [ERROR_MARKER]: !0, name: "Error", message: String(value) };
+  let properties = {};
+  for (let key of Object.keys(value))
+    RESERVED_KEYS.has(key) || (properties[key] = toTransportSafe(value[key]));
+  return {
+    [ERROR_MARKER]: !0,
+    name: value.name,
+    message: value.message,
+    ...value.stack !== void 0 ? { stack: value.stack } : {},
+    ...value.cause !== void 0 ? { cause: toTransportSafe(value.cause) } : {},
+    ...Object.keys(properties).length > 0 ? { properties } : {}
+  };
+}
+function fromTransportSafe(value) {
+  if (isSerializedError(value))
+    return deserializeError(value);
+  if (Array.isArray(value))
+    return value.map((entry) => fromTransportSafe(entry));
+  if (isPlainObject2(value)) {
+    let result = {};
+    for (let [key, entry] of Object.entries(value))
+      result[key] = fromTransportSafe(entry);
+    return result;
+  }
+  return value;
+}
+function deserializeError(serialized) {
+  let error = new Error(serialized.message);
+  if (error.name = serialized.name, serialized.stack !== void 0 && (error.stack = serialized.stack), "cause" in serialized && (error.cause = fromTransportSafe(serialized.cause)), serialized.properties)
+    for (let [key, value] of Object.entries(serialized.properties))
+      error[key] = fromTransportSafe(value);
+  return error;
+}
+
+// src/shared/open-service/service-transport.ts
+var REMOTE_COMMAND_ACK_TIMEOUT_MS = 300, SYNC_REQUEST_SILENCE_MS = 1e3;
+function createEntryAuthor(context) {
+  let { serviceId, ownRuntimeId, reconciler, channel } = context;
+  return ({ command, ops, inverse }) => {
+    let stamp = reconciler.advanceLocal(ownRuntimeId, { command, patch: ops, inverse });
+    channel.emit(SERVICE_ENTRY, {
+      serviceId,
+      stamp,
+      command,
+      patch: ops
+    });
+  };
+}
+function connectRuntimeToChannel(context) {
+  let { serviceId, ownRuntimeId, reconciler, getSnapshot, channel, 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, channel.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) && channel.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, channel.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 && channel.emit(SERVICE_ENTRY, payload), needsRepair && emitSyncRequest();
+    }
+  };
+  return channel.on(SERVICE_SYNC_REQUEST, onSyncRequest), channel.on(SERVICE_SYNC_REPLY, onSyncReply), channel.on(SERVICE_ENTRY, onEntry), emitSyncRequest(), () => {
+    channel.off(SERVICE_SYNC_REQUEST, onSyncRequest), channel.off(SERVICE_SYNC_REPLY, onSyncReply), channel.off(SERVICE_ENTRY, onEntry), repairQueued = !1, requestOutstanding = !1, withinReplyWindow = !1, clearSilenceTimer();
+  };
+}
+function connectCommandTransport(context) {
+  let {
+    serviceId,
+    ownRuntimeId,
+    channel,
+    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 && channel.emit(SERVICE_COMMAND_UNHANDLED, {
+        serviceId,
+        callId: invoke.callId
+      });
+      return;
+    }
+    channel.emit(SERVICE_COMMAND_ACK, {
+      serviceId,
+      callId: invoke.callId,
+      runtimeId: ownRuntimeId
+    }), setTimeout(() => {
+      Promise.resolve().then(() => localCommands[invoke.commandName](invoke.input)).then(
+        (result) => {
+          channel.emit(SERVICE_COMMAND_RESULT, {
+            serviceId,
+            callId: invoke.callId,
+            result,
+            runtimeId: ownRuntimeId
+          });
+        },
+        (error) => {
+          channel.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
+        })
+      )
+    );
+  };
+  channel.on(SERVICE_COMMAND_INVOKE, onInvoke), channel.on(SERVICE_COMMAND_RESULT, onResult), channel.on(SERVICE_COMMAND_ERROR, onError), channel.on(SERVICE_COMMAND_ACK, onAck), channel.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 }), channel.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: () => {
+      channel.off(SERVICE_COMMAND_INVOKE, onInvoke), channel.off(SERVICE_COMMAND_RESULT, onResult), channel.off(SERVICE_COMMAND_ERROR, onError), channel.off(SERVICE_COMMAND_ACK, onAck), channel.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, isServiceRegistered, isDelegated } = context, onInvoke = (payload) => {
+    let parsed = v4.safeParse(commandInvokeSchema, payload);
+    !parsed.success || isDelegated() || isServiceRegistered(parsed.output.serviceId) || channel.emit(SERVICE_COMMAND_UNHANDLED, {
+      serviceId: parsed.output.serviceId,
+      callId: parsed.output.callId
+    });
+  };
+  return channel.on(SERVICE_COMMAND_INVOKE, onInvoke), () => {
+    channel.off(SERVICE_COMMAND_INVOKE, onInvoke);
+  };
+}
+function connectServiceToChannel(context) {
+  let {
+    serviceId,
+    ownRuntimeId,
+    reconciler,
+    getSnapshot,
+    channel,
+    relay,
+    commands,
+    implementedCommandNames,
+    commandNames,
+    delegated,
+    runtime
+  } = context;
+  runtime.attachEntryAuthor(createEntryAuthor({ serviceId, ownRuntimeId, reconciler, channel }));
+  let commandTransport = connectCommandTransport({
+    serviceId,
+    ownRuntimeId,
+    channel,
+    localCommands: commands,
+    implementedCommandNames,
+    commandNames,
+    delegated
+  }), disconnectSync = connectRuntimeToChannel({
+    serviceId,
+    ownRuntimeId,
+    reconciler,
+    getSnapshot,
+    channel,
+    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 isDelegatedMode() {
+  return getInventory().delegatedMode;
+}
+function ensureUnknownServiceReporter(channel) {
+  let inventory = getInventory();
+  inventory.unknownServiceReporter?.channel !== channel && (inventory.unknownServiceReporter?.disconnect(), inventory.unknownServiceReporter = {
+    channel,
+    disconnect: connectUnknownServiceReporter({
+      channel,
+      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 } = {}) {
+  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
+  }), getSnapshot = () => runtime.getStateSnapshot(), descriptor = describeDefinition(resolvedDefinition), channel = getChannel();
+  if (!channel)
+    throw new OpenServiceMissingChannelError({ serviceId: definition.id });
+  getInventory().everRegisteredIds.add(definition.id), ensureUnknownServiceReporter(channel);
+  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,
+    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;
+}
+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;
+}
+
+// src/shared/open-service/static-fetch.ts
+var STATIC_SERVICES_PREFIX = "./services/";
+function shouldUseBrowserStaticLoader() {
+  return globalThis.CONFIG_TYPE === "PRODUCTION";
+}
+function createBrowserStaticLoader() {
+  if (shouldUseBrowserStaticLoader())
+    return async (logicalPath, context) => {
+      let url = `${STATIC_SERVICES_PREFIX}${logicalPath}`, res;
+      try {
+        res = await fetch(url);
+      } catch (cause) {
+        throw new OpenServiceStaticSnapshotLoadError({ ...context, logicalPath, url, cause });
+      }
+      if (!res.ok) {
+        let cause = { status: res.status, statusText: res.statusText };
+        throw new OpenServiceStaticSnapshotLoadError({
+          ...context,
+          logicalPath,
+          url,
+          cause,
+          status: res.status,
+          statusText: res.statusText
+        });
+      }
+      let snapshot;
+      try {
+        snapshot = await res.json();
+      } catch (cause) {
+        throw new OpenServiceStaticSnapshotLoadError({ ...context, logicalPath, url, cause });
+      }
+      if (snapshot && typeof snapshot == "object" && !Array.isArray(snapshot))
+        return snapshot;
+      throw new OpenServiceStaticSnapshotInvalidError({
+        ...context,
+        logicalPath,
+        url,
+        received: snapshot
+      });
+    };
+}
+
+export {
+  registerService,
+  getService,
+  createBrowserStaticLoader
+};