storybook/dist/_browser-chunks/chunk-W6Y3UHOT.js

Storybook: Develop, document, and test UI components in isolation

import {
  OpenServiceAsyncSchemaError,
  OpenServiceInvalidStaticPathError,
  OpenServiceLoadedDrainExceededError,
  OpenServiceMissingChannelError,
  OpenServiceMissingServiceError,
  OpenServiceRemoteCommandDisconnectedError,
  OpenServiceRemoteCommandUnhandledError,
  OpenServiceUnimplementedOperationError,
  OpenServiceValidationError
} from "./chunk-KUHYVZJN.js";
import {
  buildQueryState,
  toError
} from "./chunk-QC4HFS6K.js";
import {
  isEqual
} from "./chunk-Z3B64JMR.js";
import {
  getChannel
} from "./chunk-KK3JJ3E4.js";
import {
  OpenServiceStaticSnapshotInvalidError,
  OpenServiceStaticSnapshotLoadError
} from "./chunk-IUGBVGDA.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), "");

// ../../node_modules/valibot/dist/index.mjs
var store$4, DEFAULT_CONFIG = {
  lang: void 0,
  message: void 0,
  abortEarly: void 0,
  abortPipeEarly: void 0
};
function getGlobalConfig(config$1) {
  return !config$1 && !store$4 ? DEFAULT_CONFIG : {
    lang: config$1?.lang ?? store$4?.lang,
    message: config$1?.message,
    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
  };
}
var store$3;
function getGlobalMessage(lang) {
  return store$3?.get(lang);
}
var store$2;
function getSchemaMessage(lang) {
  return store$2?.get(lang);
}
var store$1;
function getSpecificMessage(reference, lang) {
  return store$1?.get(reference)?.get(lang);
}
function _stringify(input) {
  let type = typeof input;
  return type === "string" ? `"${input}"` : type === "number" || type === "bigint" || type === "boolean" ? `${input}` : type === "object" || type === "function" ? (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null" : type;
}
function _addIssue(context, label, dataset, config$1, other) {
  let input = other && "input" in other ? other.input : dataset.value, expected = other?.expected ?? context.expects ?? null, received = other?.received ?? _stringify(input), issue = {
    kind: context.kind,
    type: context.type,
    input,
    expected,
    received,
    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
    requirement: context.requirement,
    path: other?.path,
    issues: other?.issues,
    lang: config$1.lang,
    abortEarly: config$1.abortEarly,
    abortPipeEarly: config$1.abortPipeEarly
  }, isSchema = context.kind === "schema", message$1 = other?.message ?? context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config$1.message ?? getGlobalMessage(issue.lang);
  message$1 !== void 0 && (issue.message = typeof message$1 == "function" ? message$1(issue) : message$1), isSchema && (dataset.typed = !1), dataset.issues ? dataset.issues.push(issue) : dataset.issues = [issue];
}
var _standardCache = /* @__PURE__ */ new WeakMap();
function _getStandardProps(context) {
  let cached = _standardCache.get(context);
  return cached || (cached = {
    version: 1,
    vendor: "valibot",
    validate(value$1) {
      return context["~run"]({ value: value$1 }, getGlobalConfig());
    }
  }, _standardCache.set(context, cached)), cached;
}
function _isValidObjectKey(object$1, key) {
  return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
}
var EMOJI_REGEX = new RegExp("^(?:[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation}))*)+$", "u");
function minValue(requirement, message$1) {
  return {
    kind: "validation",
    type: "min_value",
    reference: minValue,
    async: !1,
    expects: `>=${requirement instanceof Date ? requirement.toJSON() : _stringify(requirement)}`,
    requirement,
    message: message$1,
    "~run"(dataset, config$1) {
      return dataset.typed && !(dataset.value >= this.requirement) && _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value) }), dataset;
    }
  };
}
function safeInteger(message$1) {
  return {
    kind: "validation",
    type: "safe_integer",
    reference: safeInteger,
    async: !1,
    expects: null,
    requirement: Number.isSafeInteger,
    message: message$1,
    "~run"(dataset, config$1) {
      return dataset.typed && !this.requirement(dataset.value) && _addIssue(this, "safe integer", dataset, config$1), dataset;
    }
  };
}
function getFallback(schema, dataset, config$1) {
  return typeof schema.fallback == "function" ? schema.fallback(dataset, config$1) : schema.fallback;
}
function getDefault(schema, dataset, config$1) {
  return typeof schema.default == "function" ? schema.default(dataset, config$1) : schema.default;
}
function array(item, message$1) {
  return {
    kind: "schema",
    type: "array",
    reference: array,
    expects: "Array",
    async: !1,
    item,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      let input = dataset.value;
      if (Array.isArray(input)) {
        dataset.typed = !0, dataset.value = [];
        for (let key = 0; key < input.length; key++) {
          let value$1 = input[key], itemDataset = this.item["~run"]({ value: value$1 }, config$1);
          if (itemDataset.issues) {
            let pathItem = {
              type: "array",
              origin: "value",
              input,
              key,
              value: value$1
            };
            for (let issue of itemDataset.issues)
              issue.path ? issue.path.unshift(pathItem) : issue.path = [pathItem], dataset.issues?.push(issue);
            if (dataset.issues || (dataset.issues = itemDataset.issues), config$1.abortEarly) {
              dataset.typed = !1;
              break;
            }
          }
          itemDataset.typed || (dataset.typed = !1), dataset.value.push(itemDataset.value);
        }
      } else _addIssue(this, "type", dataset, config$1);
      return dataset;
    }
  };
}
function custom(check$1, message$1) {
  return {
    kind: "schema",
    type: "custom",
    reference: custom,
    expects: "unknown",
    async: !1,
    check: check$1,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      return this.check(dataset.value) ? dataset.typed = !0 : _addIssue(this, "type", dataset, config$1), dataset;
    }
  };
}
function looseObject(entries$1, message$1) {
  return {
    kind: "schema",
    type: "loose_object",
    reference: looseObject,
    expects: "Object",
    async: !1,
    entries: entries$1,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      let input = dataset.value;
      if (input && typeof input == "object") {
        dataset.typed = !0, dataset.value = {};
        for (let key in this.entries) {
          let valueSchema = this.entries[key];
          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
            let value$1 = key in input ? input[key] : getDefault(valueSchema), valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
            if (valueDataset.issues) {
              let pathItem = {
                type: "object",
                origin: "value",
                input,
                key,
                value: value$1
              };
              for (let issue of valueDataset.issues)
                issue.path ? issue.path.unshift(pathItem) : issue.path = [pathItem], dataset.issues?.push(issue);
              if (dataset.issues || (dataset.issues = valueDataset.issues), config$1.abortEarly) {
                dataset.typed = !1;
                break;
              }
            }
            valueDataset.typed || (dataset.typed = !1), dataset.value[key] = valueDataset.value;
          } else if (valueSchema.fallback !== void 0) dataset.value[key] = getFallback(valueSchema);
          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish" && (_addIssue(this, "key", dataset, config$1, {
            input: void 0,
            expected: `"${key}"`,
            path: [{
              type: "object",
              origin: "key",
              input,
              key,
              value: input[key]
            }]
          }), config$1.abortEarly))
            break;
        }
        if (!dataset.issues || !config$1.abortEarly)
          for (let key in input) _isValidObjectKey(input, key) && !(key in this.entries) && (dataset.value[key] = input[key]);
      } else _addIssue(this, "type", dataset, config$1);
      return dataset;
    }
  };
}
function number(message$1) {
  return {
    kind: "schema",
    type: "number",
    reference: number,
    expects: "number",
    async: !1,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      return typeof dataset.value == "number" && !isNaN(dataset.value) ? dataset.typed = !0 : _addIssue(this, "type", dataset, config$1), dataset;
    }
  };
}
function object(entries$1, message$1) {
  return {
    kind: "schema",
    type: "object",
    reference: object,
    expects: "Object",
    async: !1,
    entries: entries$1,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      let input = dataset.value;
      if (input && typeof input == "object") {
        dataset.typed = !0, dataset.value = {};
        for (let key in this.entries) {
          let valueSchema = this.entries[key];
          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
            let value$1 = key in input ? input[key] : getDefault(valueSchema), valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
            if (valueDataset.issues) {
              let pathItem = {
                type: "object",
                origin: "value",
                input,
                key,
                value: value$1
              };
              for (let issue of valueDataset.issues)
                issue.path ? issue.path.unshift(pathItem) : issue.path = [pathItem], dataset.issues?.push(issue);
              if (dataset.issues || (dataset.issues = valueDataset.issues), config$1.abortEarly) {
                dataset.typed = !1;
                break;
              }
            }
            valueDataset.typed || (dataset.typed = !1), dataset.value[key] = valueDataset.value;
          } else if (valueSchema.fallback !== void 0) dataset.value[key] = getFallback(valueSchema);
          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish" && (_addIssue(this, "key", dataset, config$1, {
            input: void 0,
            expected: `"${key}"`,
            path: [{
              type: "object",
              origin: "key",
              input,
              key,
              value: input[key]
            }]
          }), config$1.abortEarly))
            break;
        }
      } else _addIssue(this, "type", dataset, config$1);
      return dataset;
    }
  };
}
function optional(wrapped, default_) {
  return {
    kind: "schema",
    type: "optional",
    reference: optional,
    expects: `(${wrapped.expects} | undefined)`,
    async: !1,
    wrapped,
    default: default_,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      return dataset.value === void 0 && (this.default !== void 0 && (dataset.value = getDefault(this, dataset, config$1)), dataset.value === void 0) ? (dataset.typed = !0, dataset) : this.wrapped["~run"](dataset, config$1);
    }
  };
}
function record(key, value$1, message$1) {
  return {
    kind: "schema",
    type: "record",
    reference: record,
    expects: "Object",
    async: !1,
    key,
    value: value$1,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      let input = dataset.value;
      if (input && typeof input == "object") {
        dataset.typed = !0, dataset.value = {};
        for (let entryKey in input) if (_isValidObjectKey(input, entryKey)) {
          let entryValue = input[entryKey], keyDataset = this.key["~run"]({ value: entryKey }, config$1);
          if (keyDataset.issues) {
            let pathItem = {
              type: "object",
              origin: "key",
              input,
              key: entryKey,
              value: entryValue
            };
            for (let issue of keyDataset.issues)
              issue.path = [pathItem], dataset.issues?.push(issue);
            if (dataset.issues || (dataset.issues = keyDataset.issues), config$1.abortEarly) {
              dataset.typed = !1;
              break;
            }
          }
          let valueDataset = this.value["~run"]({ value: entryValue }, config$1);
          if (valueDataset.issues) {
            let pathItem = {
              type: "object",
              origin: "value",
              input,
              key: entryKey,
              value: entryValue
            };
            for (let issue of valueDataset.issues)
              issue.path ? issue.path.unshift(pathItem) : issue.path = [pathItem], dataset.issues?.push(issue);
            if (dataset.issues || (dataset.issues = valueDataset.issues), config$1.abortEarly) {
              dataset.typed = !1;
              break;
            }
          }
          (!keyDataset.typed || !valueDataset.typed) && (dataset.typed = !1), keyDataset.typed && (dataset.value[keyDataset.value] = valueDataset.value);
        }
      } else _addIssue(this, "type", dataset, config$1);
      return dataset;
    }
  };
}
function string(message$1) {
  return {
    kind: "schema",
    type: "string",
    reference: string,
    expects: "string",
    async: !1,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      return typeof dataset.value == "string" ? dataset.typed = !0 : _addIssue(this, "type", dataset, config$1), dataset;
    }
  };
}
function undefined_(message$1) {
  return {
    kind: "schema",
    type: "undefined",
    reference: undefined_,
    expects: "undefined",
    async: !1,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      return dataset.value === void 0 ? dataset.typed = !0 : _addIssue(this, "type", dataset, config$1), dataset;
    }
  };
}
function unknown() {
  return {
    kind: "schema",
    type: "unknown",
    reference: unknown,
    expects: "unknown",
    async: !1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset) {
      return dataset.typed = !0, dataset;
    }
  };
}
function void_(message$1) {
  return {
    kind: "schema",
    type: "void",
    reference: void_,
    expects: "void",
    async: !1,
    message: message$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      return dataset.value === void 0 ? dataset.typed = !0 : _addIssue(this, "type", dataset, config$1), dataset;
    }
  };
}
function pipe(...pipe$1) {
  return {
    ...pipe$1[0],
    pipe: pipe$1,
    get "~standard"() {
      return _getStandardProps(this);
    },
    "~run"(dataset, config$1) {
      for (let item of pipe$1) if (item.kind !== "metadata") {
        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
          dataset.typed = !1;
          break;
        }
        (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) && (dataset = item["~run"](dataset, config$1));
      }
      return dataset;
    }
  };
}
function safeParse(schema, input, config$1) {
  let dataset = schema["~run"]({ value: input }, getGlobalConfig(config$1));
  return {
    typed: dataset.typed,
    success: !dataset.issues,
    output: dataset.value,
    issues: dataset.issues
  };
}

// src/shared/open-service/service-channel.ts
var SERVICE_SYNC_START = "services:sync-start", SERVICE_SYNC_START_REPLY = "services:sync-start-reply", SERVICE_PATCHES = "services:patches", SERVICE_COMMAND_INVOKE = "services:command-invoke", SERVICE_COMMAND_ACK = "services:command-ack", SERVICE_COMMAND_RESULT = "services:command-result", SERVICE_COMMAND_ERROR = "services:command-error", stateSnapshotSchema = custom(
  (value) => typeof value == "object" && value !== null && !Array.isArray(value)
), syncStartSchema = object({
  serviceId: string(),
  clientId: string()
}), stampedSnapshotSchema = object({
  serviceId: string(),
  state: stateSnapshotSchema,
  version: pipe(number(), safeInteger(), minValue(0)),
  clientId: string()
}), commandInvokeSchema = object({
  serviceId: string(),
  commandName: string(),
  input: optional(unknown()),
  callId: string(),
  clientId: string()
}), commandAckSchema = object({
  serviceId: string(),
  callId: string(),
  clientId: string()
}), commandResultSchema = object({
  serviceId: string(),
  callId: string(),
  result: optional(unknown()),
  clientId: string()
}), commandErrorSchema = object({
  serviceId: string(),
  callId: string(),
  error: custom(
    (value) => typeof value == "object" && value !== null && !Array.isArray(value)
  ),
  clientId: string()
});
function generateClientId() {
  return nanoid();
}

// ../../node_modules/@preact/signals-core/dist/signals-core.module.js
var i = /* @__PURE__ */ Symbol.for("preact-signals");
function t() {
  if (s > 1)
    s--;
  else {
    var i3, t2 = !1;
    for ((function() {
      var i4 = c;
      for (c = void 0; i4 !== void 0; )
        i4.S.v === i4.v && (i4.S.i = i4.i), i4 = i4.o;
    })(); h !== void 0; ) {
      var n3 = h;
      for (h = void 0, v++; 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 (v = 0, s--, t2) throw i3;
  }
}
function n(i3) {
  if (s > 0) return i3();
  e = ++u, s++;
  try {
    return i3();
  } finally {
    t();
  }
}
var r = void 0;
function o(i3) {
  var t2 = r;
  r = void 0;
  try {
    return i3();
  } finally {
    r = t2;
  }
}
var f, h = void 0, s = 0, v = 0, u = 0, e = 0, c = void 0, d = 0;
function a(i3) {
  if (r !== void 0) {
    var t2 = i3.n;
    if (t2 === void 0 || t2.t !== r)
      return t2 = { i: 0, S: i3, p: r.s, n: void 0, t: r, e: void 0, x: void 0, r: t2 }, r.s !== void 0 && (r.s.n = t2), r.s = t2, i3.n = t2, 32 & r.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 = r.s, t2.n = void 0, r.s.n = t2, r.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 : o(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 && o(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, o3 = r;
    r = void 0;
    try {
      i3(n3);
    } finally {
      r = o3;
    }
  }, { 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 o(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 (v > 100) throw new Error("Cycle detected");
    (function(i4) {
      s !== 0 && v === 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++, s++;
    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), this.x = i3, this.s = void 0, this.g = d - 1, this.f = 4, this.W = t2?.watched, this.Z = t2?.unwatched, this.name = t2?.name;
}
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 = r;
  try {
    _(this), r = 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 r = 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") {
    s++;
    var o3 = r;
    r = void 0;
    try {
      n3();
    } catch (t2) {
      throw i3.f &= -2, i3.f |= 8, m(i3), t2;
    } finally {
      r = o3, 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 (r !== this) throw new Error("Out-of-order effect");
  b(this), r = 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, f && f.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), s++;
  var i3 = r;
  return r = 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);
};
var p2 = function(e2, t2) {
  var r2 = new Proxy(e2, t2);
  return s2.add(r2), r2;
}, v2 = function() {
  throw new Error("Don't mutate the signals directly.");
}, y2 = function(e2) {
  return function(s3, u3, l3) {
    var g2;
    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 v3 = n2.get(l3), y3 = h2 ? u3.replace(f2, "") : u3;
    if (v3.has(y3) || typeof ((g2 = c2(s3, y3)) == null ? void 0 : g2.get) != "function") {
      var m3 = Reflect.get(s3, y3, l3);
      if (h2 && typeof m3 == "function") return;
      if (typeof y3 == "symbol" && b2.has(y3)) return m3;
      v3.has(y3) || (R(m3) && (a2.has(m3) || a2.set(m3, p2(m3, w2)), m3 = a2.get(m3)), v3.set(y3, y(m3)));
    } else v3.set(y3, g(function() {
      return Reflect.get(s3, y3, l3);
    }));
    return h2 ? v3.get(y3) : v3.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 g2 = n2.get(i3);
  if (o3[0] === "$") {
    s3 instanceof l || v2();
    var h2 = o3.replace(f2, "");
    return g2.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 g2.has(o3) ? g2.get(o3).value = y3 : g2.set(o3, y(y3)), d3 && u2.has(r2) && u2.get(r2).value++, Array.isArray(r2) && g2.has("length") && (g2.get("length").value = r2.length), b3;
}, deleteProperty: function(e2, t2) {
  t2[0] === "$" && v2();
  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: v2, deleteProperty: v2 }, 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/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(), 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 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 existing = inFlightLoads.get(loadKey);
  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(loadKey) === promise && inFlightLoads.delete(loadKey);
  });
  return inFlightLoads.set(loadKey, 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 = o(() => 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 = o(() => 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
function isNewer(incoming, local) {
  return incoming.version !== local.version ? incoming.version > local.version : incoming.clientId > local.clientId;
}
var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
function isPlainObject(value) {
  return typeof value == "object" && value !== null && !Array.isArray(value);
}
function applyStatePatch(target, source, options) {
  if (!options.preserveMissingKeys)
    for (let key of Object.keys(target))
      FORBIDDEN_KEYS.has(key) || Object.prototype.hasOwnProperty.call(source, key) || delete target[key];
  for (let key of Object.keys(source)) {
    if (FORBIDDEN_KEYS.has(key))
      continue;
    let sourceValue = source[key], tarvalue = target[key];
    isPlainObject(sourceValue) && isPlainObject(tarvalue) ? applyStatePatch(tarvalue, sourceValue, options) : tarvalue !== sourceValue && (target[key] = sourceValue);
  }
}
function createSnapshotReconciler(options) {
  let { setState, initialStamp } = options, localStamp = initialStamp;
  return {
    get stamp() {
      return localStamp;
    },
    advanceLocal(clientId) {
      return localStamp = { version: localStamp.version + 1, clientId }, localStamp;
    },
    tryAdopt(incoming, state) {
      return isNewer(incoming, localStamp) ? (localStamp = { version: incoming.version, clientId: incoming.clientId }, setState((current) => applyStatePatch(current, state, { preserveMissingKeys: !1 })), !0) : !1;
    }
  };
}

// 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 createCommandSelf(state) {
  return {
    get state() {
      return state;
    },
    setState(mutate) {
      n(() => {
        mutate(state);
      });
    },
    queries: {},
    commands: {}
  };
}
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());
        return validateSchema(def.output, output, {
          kind: "command",
          serviceId,
          name,
          phase: "output"
        });
      }
    ])
  );
}
function buildQueryDefinitionsWithStaticLoader(serviceId, queries, staticLoader, setState) {
  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
            });
            setState((state) => {
              applyStatePatch(state, snapshot, {
                preserveMissingKeys: !0
              });
            });
          }
        }
      ];
    })
  );
}
function createServiceRuntime(def, runtimeOptions, initialState = def.initialState) {
  let rawState = initialState, state = l2(rawState), getStateSnapshot = () => structuredClone(rawState), commandSelf = createCommandSelf(state), { registryApi, staticLoader } = runtimeOptions, createCommandCtx = () => ({
    self: commandSelf,
    getService: registryApi.getService
  }), commands = buildCommands(def.id, def.commands, createCommandCtx);
  commandSelf.commands = commands;
  let loadCommands = commands, remoteCommandNames = /* @__PURE__ */ new Set(), queryDefinitions = staticLoader ? buildQueryDefinitionsWithStaticLoader(
    def.id,
    def.queries,
    staticLoader,
    commandSelf.setState
  ) : new Map(
    Object.entries(def.queries)
  ), defaultQueries = {}, reactiveLoadQueries = {}, buildGatedCommands = (isCurrent) => {
    let gatedSelf = {
      get state() {
        return state;
      },
      setState(mutate) {
        isCurrent() && n(() => {
          mutate(state);
        });
      },
      queries: defaultQueries,
      commands: {}
    }, gated = buildCommands(def.id, def.commands, () => ({
      self: gatedSelf,
      getService: registryApi.getService
    }));
    return gatedSelf.commands = gated, remoteCommandNames.size === 0 ? gated : Object.fromEntries(
      Object.keys(def.commands).map((name) => [
        name,
        remoteCommandNames.has(name) ? loadCommands[name] : gated[name]
      ])
    );
  }, refs = {
    serviceId: def.id,
    commandSelf,
    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;
  commandSelf.queries = defaultQueries;
  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,
    commandSelf,
    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]), previous = inFlightLoads.get(loadKey), promise = Promise.resolve().then(() => runLoadBody(refs, queryName, queryDef, validatedInput, ancestorChain)).finally(() => {
        inFlightLoads.get(loadKey) === promise && (previous ? inFlightLoads.set(loadKey, previous) : inFlightLoads.delete(loadKey));
      });
      inFlightLoads.set(loadKey, 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-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]: