zocket 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,3056 +1,5 @@
-// ../orbz/src/utils/runtime.js
-var _baseAnchor;
-var hasSetDefault = false;
-var MEM = {
-  get BASE_ANCHOR() {
-    return _baseAnchor;
-  },
-  set BASE_ANCHOR(anchor) {
-    if (hasSetDefault) {
-      throw new Error("cannot update base anchor");
-    }
-    _baseAnchor = anchor;
-    hasSetDefault = true;
-  },
-  LAST_ANCHOR_ID: 1,
-  ORB_META: new WeakMap,
-  ORB_STATE: new WeakMap,
-  ORB_PLAN: new WeakMap,
-  ORB_GETTER_CACHE: new WeakMap,
-  FACTORY_PLAN: new WeakMap,
-  MOUNTS: new WeakMap,
-  MOUNT_FACTORIES: new WeakMap,
-  SHAPE_NAMES: new Set,
-  LINKS_BY_SOURCE: new Map,
-  INSPECTORS: new Set
-};
-var VOCAB = {
-  SHAPE: {
-    NAME: Symbol.for("orbz.Shape.name"),
-    INIT: Symbol.for("orbz.Shape.init"),
-    KEYS: Symbol.for("orbz.Shape.keys"),
-    EDGE: Symbol.for("orbz.Shape.edge"),
-    SAVE: Symbol.for("orbz.Shape.save"),
-    LOAD: Symbol.for("orbz.Shape.load"),
-    MOUNTS: Symbol.for("orbz.Shape.mounts")
-  }
-};
-VOCAB.SHAPE_SYMBOLS = new Set(Object.values(VOCAB.SHAPE));
-var ROUTE_SEGMENT = /^[A-Za-z0-9._~-]+$/;
-function assertRouteSegment(segment) {
-  if (typeof segment !== "string" || segment.length === 0 || !ROUTE_SEGMENT.test(segment)) {
-    throw new Error("Route segments must be non-empty URL-safe strings");
-  }
-}
-
-// ../orbz/src/utils/shapePlan.js
-var hasOwn = Object.prototype.hasOwnProperty;
-function createShapePlan(definition, options = {}) {
-  if (!definition || typeof definition !== "object") {
-    throw new TypeError("Shape definition must be an object");
-  }
-  const descriptors = Object.getOwnPropertyDescriptors(definition);
-  const identity = readShapeIdentity(descriptors);
-  const parents = options.parents ?? [];
-  const directParents = parents.map((plan2) => ({ id: plan2.id, name: plan2.name }));
-  const ancestry = uniqueShapeRefs([
-    ...parents.flatMap((parent) => parent.ancestry),
-    ...directParents
-  ]);
-  const plan = {
-    id: identity.id,
-    name: identity.name,
-    parents: directParents,
-    ancestry,
-    ancestryIds: new Set(ancestry.map((parent) => parent.id)),
-    descriptors,
-    entries: [],
-    byKey: new Map,
-    state: [],
-    publicState: [],
-    internalState: [],
-    slots: [],
-    serializable: [],
-    enumerable: [],
-    getters: [],
-    pairedAccessors: [],
-    shortcutSetters: [],
-    methods: [],
-    generatorMethods: [],
-    protocol: {
-      init: undefined,
-      keys: undefined,
-      edge: undefined,
-      save: undefined,
-      load: undefined
-    },
-    mounts: {}
-  };
-  let mountDescriptors;
-  for (const key of Reflect.ownKeys(descriptors)) {
-    if (typeof key === "symbol") {
-      if (!VOCAB.SHAPE_SYMBOLS.has(key)) {
-        throw new Error("Shape definitions may not use arbitrary symbol keys");
-      }
-      if (key === VOCAB.SHAPE.MOUNTS) {
-        mountDescriptors = readMountDescriptors(descriptors[key]);
-        continue;
-      }
-      indexProtocolMember(plan, key, descriptors[key]);
-      continue;
-    }
-    if (key === "$") {
-      throw new Error("Shape cannot define reserved key '$'");
-    }
-    const descriptor = descriptors[key];
-    const entry = classifyShapeMember(key, descriptor);
-    if (entry.meta.serializable) {
-      assertRouteSegment(key);
-    }
-    plan.entries.push(entry);
-    plan.byKey.set(key, entry);
-    indexShapeEntry(plan, entry);
-  }
-  plan.mounts = normalizeMountDescriptors(mountDescriptors, plan);
-  registerShapeName(identity.name);
-  return plan;
-}
-function createExtendedShapeDefinition(parentPlans, definition) {
-  if (!definition || typeof definition !== "object") {
-    throw new TypeError("Shape definition must be an object");
-  }
-  const merged = {};
-  for (const parent of parentPlans) {
-    for (const [key, descriptor] of Object.entries(parent.descriptors)) {
-      Object.defineProperty(merged, key, descriptor);
-    }
-  }
-  for (const key of Reflect.ownKeys(definition)) {
-    Object.defineProperty(merged, key, Object.getOwnPropertyDescriptor(definition, key));
-  }
-  return merged;
-}
-function indexProtocolMember(plan, key, descriptor) {
-  if (key === VOCAB.SHAPE.NAME) {
-    return;
-  }
-  if (!Object.prototype.hasOwnProperty.call(descriptor, "value") || typeof descriptor.value !== "function") {
-    throw new Error("Shape protocol members must be methods");
-  }
-  if (key === VOCAB.SHAPE.INIT) {
-    plan.protocol.init = descriptor.value;
-  } else if (key === VOCAB.SHAPE.KEYS) {
-    plan.protocol.keys = descriptor.value;
-  } else if (key === VOCAB.SHAPE.EDGE) {
-    plan.protocol.edge = descriptor.value;
-  } else if (key === VOCAB.SHAPE.SAVE) {
-    plan.protocol.save = descriptor.value;
-  } else if (key === VOCAB.SHAPE.LOAD) {
-    plan.protocol.load = descriptor.value;
-  } else if (key === VOCAB.SHAPE.MOUNTS) {
-    return;
-  } else {
-    throw new Error("Unknown Shape protocol member");
-  }
-}
-function readShapeIdentity(descriptors) {
-  const nameDescriptor = descriptors[VOCAB.SHAPE.NAME];
-  if (!nameDescriptor || !Object.prototype.hasOwnProperty.call(nameDescriptor, "value")) {
-    throw new Error("Shape.name is required");
-  }
-  const name = nameDescriptor.value;
-  if (typeof name !== "string" || name.length === 0) {
-    throw new TypeError("Shape.name must be a non-empty string");
-  }
-  return { id: name, name };
-}
-function uniqueShapeRefs(refs) {
-  const seen = new Set;
-  const out = [];
-  for (const ref of refs) {
-    if (seen.has(ref.id))
-      continue;
-    seen.add(ref.id);
-    out.push(ref);
-  }
-  return out;
-}
-function registerShapeName(name) {
-  if (MEM.SHAPE_NAMES.has(name)) {
-    throw new Error(`Shape '${name}' is already defined`);
-  }
-  MEM.SHAPE_NAMES.add(name);
-}
-function classifyShapeMember(key, descriptor) {
-  const hasValue = hasOwn.call(descriptor, "value");
-  const hasGetter = typeof descriptor.get === "function";
-  const hasSetter = typeof descriptor.set === "function";
-  const internal = key.startsWith("_");
-  if (hasValue) {
-    if (typeof descriptor.value === "function") {
-      if (isOrbFactory(descriptor.value)) {
-        return {
-          key,
-          kind: "slot",
-          value: descriptor.value,
-          shapeId: descriptor.value.shapeId,
-          descriptor,
-          meta: {
-            visibility: internal ? "internal" : "public",
-            internal,
-            enumerable: !internal,
-            serializable: true,
-            writableFromPublic: !internal,
-            writableFromBehavior: true,
-            acceptedInConstructor: true
-          }
-        };
-      }
-      const generator = isGeneratorFunction(descriptor.value);
-      return {
-        key,
-        kind: generator ? "generatorMethod" : "method",
-        value: descriptor.value,
-        descriptor,
-        meta: {
-          internal: false,
-          enumerable: false,
-          serializable: false
-        }
-      };
-    }
-    assertJsonCompatibleStateDefault(key, descriptor.value);
-    return {
-      key,
-      kind: "state",
-      value: descriptor.value,
-      descriptor,
-      meta: {
-        visibility: internal ? "internal" : "public",
-        internal,
-        enumerable: !internal,
-        serializable: true,
-        writableFromPublic: !internal,
-        writableFromBehavior: true,
-        acceptedInConstructor: true
-      }
-    };
-  }
-  if (hasGetter && hasSetter) {
-    return {
-      key,
-      kind: "pairedAccessor",
-      get: descriptor.get,
-      set: descriptor.set,
-      descriptor,
-      meta: {
-        internal,
-        enumerable: false,
-        serializable: false,
-        acceptedInConstructor: true
-      }
-    };
-  }
-  if (hasGetter) {
-    return {
-      key,
-      kind: "getter",
-      get: descriptor.get,
-      descriptor,
-      meta: {
-        internal,
-        enumerable: false,
-        serializable: false
-      }
-    };
-  }
-  if (hasSetter) {
-    return {
-      key,
-      kind: "shortcutSetter",
-      set: descriptor.set,
-      descriptor,
-      meta: {
-        internal,
-        enumerable: false,
-        serializable: false,
-        acceptedInConstructor: true
-      }
-    };
-  }
-  throw new Error(`Unsupported Shape member '${key}'`);
-}
-function indexShapeEntry(plan, entry) {
-  if (entry.kind === "state") {
-    plan.state.push(entry);
-    plan.serializable.push(entry);
-    if (entry.meta.internal) {
-      plan.internalState.push(entry);
-    } else {
-      plan.publicState.push(entry);
-      plan.enumerable.push(entry);
-    }
-  } else if (entry.kind === "slot") {
-    plan.state.push(entry);
-    plan.slots.push(entry);
-    plan.serializable.push(entry);
-    if (entry.meta.internal) {
-      plan.internalState.push(entry);
-    } else {
-      plan.publicState.push(entry);
-      plan.enumerable.push(entry);
-    }
-  } else if (entry.kind === "getter") {
-    plan.getters.push(entry);
-  } else if (entry.kind === "pairedAccessor") {
-    plan.pairedAccessors.push(entry);
-  } else if (entry.kind === "shortcutSetter") {
-    plan.shortcutSetters.push(entry);
-  } else if (entry.kind === "method") {
-    plan.methods.push(entry);
-  } else if (entry.kind === "generatorMethod") {
-    plan.generatorMethods.push(entry);
-  } else {
-    throw new Error(`Unknown Shape entry kind '${entry.kind}'`);
-  }
-}
-function readMountDescriptors(descriptor) {
-  if (!Object.prototype.hasOwnProperty.call(descriptor, "value")) {
-    throw new Error("Shape.mounts must be a plain object");
-  }
-  return descriptor.value;
-}
-function normalizeMountDescriptors(value, plan) {
-  if (value === undefined)
-    return {};
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new TypeError("Shape.mounts must be a plain object");
-  }
-  const out = {};
-  const getters = new Set(plan.getters.map((entry) => entry.key));
-  const commands = new Set([
-    ...plan.methods.map((entry) => entry.key),
-    ...plan.generatorMethods.map((entry) => entry.key)
-  ]);
-  for (const [target, rawConfig] of Object.entries(value)) {
-    assertRouteSegment(target);
-    if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
-      throw new TypeError(`Shape.mounts.${target} must be a plain object`);
-    }
-    for (const key of Object.keys(rawConfig)) {
-      if (key !== "outsource") {
-        throw new Error(`Unsupported Shape.mounts.${target} option '${key}'`);
-      }
-    }
-    const outsource = normalizeOutsourceList(rawConfig.outsource, target);
-    const projections = [];
-    const methods = [];
-    for (const key of outsource) {
-      if (getters.has(key)) {
-        projections.push(key);
-      } else if (commands.has(key)) {
-        methods.push(key);
-      } else {
-        throw new Error(`Shape.mounts.${target} cannot outsource '${key}'`);
-      }
-    }
-    out[target] = {
-      target,
-      outsource,
-      projections,
-      commands: methods
-    };
-  }
-  return out;
-}
-function normalizeOutsourceList(value, target) {
-  if (value === undefined)
-    return [];
-  if (!Array.isArray(value)) {
-    throw new TypeError(`Shape.mounts.${target}.outsource must be an array`);
-  }
-  const seen = new Set;
-  const out = [];
-  for (const key of value) {
-    if (typeof key !== "string" || key.length === 0) {
-      throw new TypeError(`Shape.mounts.${target}.outsource entries must be non-empty strings`);
-    }
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    out.push(key);
-  }
-  return out;
-}
-function isGeneratorFunction(value) {
-  return typeof value === "function" && value.constructor && value.constructor.name === "GeneratorFunction";
-}
-function isOrbFactory(value) {
-  return typeof value === "function" && typeof value.shapeId === "string";
-}
-function assertJsonCompatibleStateDefault(key, value) {
-  if (isJsonCompatibleValue(value))
-    return;
-  throw new Error(`State default '${key}' must be JSON-compatible in v1`);
-}
-function isJsonCompatibleValue(value) {
-  if (value === null)
-    return true;
-  switch (typeof value) {
-    case "string":
-    case "boolean":
-      return true;
-    case "number":
-      return Number.isFinite(value);
-    case "object":
-      return isJsonCompatibleObject(value);
-    default:
-      return false;
-  }
-}
-function isJsonCompatibleObject(value) {
-  if (Array.isArray(value)) {
-    return value.every(isJsonCompatibleValue);
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
-    return false;
-  }
-  return Object.values(value).every(isJsonCompatibleValue);
-}
-
-// ../orbz/src/utils/inspection.js
-function emitInspectionEvent(event) {
-  if (MEM.INSPECTORS.size === 0)
-    return;
-  const frozenEvent = Object.freeze({ ...event });
-  for (const listener of [...MEM.INSPECTORS]) {
-    listener(frozenEvent);
-  }
-}
-
-// ../orbz/src/utils/reactivity.js
-var activeComputation = null;
-var batchDepth = 0;
-var isFlushing = false;
-var nextRuntimeOrbId = 1;
-var DEPENDENTS = new Map;
-var pendingEffects = new Set;
-var DEPENDENCY_KEYS = new WeakMap;
-var ORB_RUNTIME_ID = new WeakMap;
-function trackDependency(orb, key) {
-  if (!activeComputation)
-    return;
-  activeComputation.nextDeps.add(createDependencyKey(orb, key));
-}
-function runTracked(computation, fn) {
-  const parentComputation = activeComputation;
-  computation.nextDeps = new Set;
-  activeComputation = computation;
-  try {
-    return fn();
-  } finally {
-    activeComputation = parentComputation;
-  }
-}
-function notifyDependencyChanged(orb, key) {
-  const dependents = DEPENDENTS.get(createDependencyKey(orb, key));
-  if (!dependents)
-    return;
-  for (const computation of [...dependents]) {
-    if (computation.type === "effect" && computation.active) {
-      pendingEffects.add(computation);
-    } else if (computation.type === "getter") {
-      computation.onDependencyChanged?.();
-    }
-  }
-  flushEffects();
-}
-function replaceSubscriptions(computation) {
-  removeSubscriptions(computation);
-  computation.deps = computation.nextDeps;
-  computation.nextDeps = new Set;
-  for (const dependency of computation.deps) {
-    let dependents = DEPENDENTS.get(dependency);
-    if (!dependents) {
-      dependents = new Set;
-      DEPENDENTS.set(dependency, dependents);
-    }
-    dependents.add(computation);
-  }
-}
-function removeSubscriptions(computation) {
-  if (!computation.deps)
-    return;
-  for (const dependency of computation.deps) {
-    const dependents = DEPENDENTS.get(dependency);
-    if (!dependents)
-      continue;
-    dependents.delete(computation);
-    if (dependents.size === 0) {
-      DEPENDENTS.delete(dependency);
-    }
-  }
-  computation.deps = new Set;
-}
-function batch(callback) {
-  emitInspectionEvent({ type: "batch:start", depth: batchDepth + 1 });
-  batchDepth++;
-  try {
-    return callback();
-  } finally {
-    batchDepth--;
-    emitInspectionEvent({ type: "batch:end", depth: batchDepth + 1 });
-    if (batchDepth === 0) {
-      flushEffects();
-    }
-  }
-}
-function fx(callback) {
-  if (typeof callback !== "function") {
-    throw new TypeError("fx() expects a callback");
-  }
-  const effect = {
-    type: "effect",
-    active: true,
-    deps: new Set,
-    nextDeps: new Set,
-    run() {
-      if (!effect.active)
-        return;
-      emitInspectionEvent({ type: "effect:run" });
-      runTracked(effect, callback);
-      replaceSubscriptions(effect);
-    }
-  };
-  effect.run();
-  return () => {
-    effect.active = false;
-    pendingEffects.delete(effect);
-    removeSubscriptions(effect);
-  };
-}
-function createDependencyKey(orb, key) {
-  let keys = DEPENDENCY_KEYS.get(orb);
-  if (!keys) {
-    keys = new Map;
-    DEPENDENCY_KEYS.set(orb, keys);
-  }
-  if (!keys.has(key)) {
-    keys.set(key, {
-      target: getOrbRuntimeId(orb),
-      key
-    });
-  }
-  return keys.get(key);
-}
-function flushEffects() {
-  if (batchDepth > 0 || isFlushing)
-    return;
-  isFlushing = true;
-  try {
-    while (pendingEffects.size > 0) {
-      const effects = [...pendingEffects];
-      pendingEffects.clear();
-      for (const effect of effects) {
-        effect.run();
-      }
-    }
-  } finally {
-    isFlushing = false;
-  }
-}
-function getOrbRuntimeId(orb) {
-  if (!ORB_RUNTIME_ID.has(orb)) {
-    ORB_RUNTIME_ID.set(orb, nextRuntimeOrbId++);
-  }
-  return ORB_RUNTIME_ID.get(orb);
-}
-function createEachEffect({ node, callback, options, keys, peek, read }) {
-  if (typeof callback !== "function") {
-    throw new TypeError("eachEffect() expects a callback");
-  }
-  const itemStops = new Map;
-  const itemValues = new Map;
-  const scope = options.scope;
-  let disposed = false;
-  const stopMembership = fx(() => {
-    const activeKeys = new Set;
-    for (const key of keys()) {
-      const value = peek(key);
-      activeKeys.add(key);
-      if (itemValues.get(key) === value && itemStops.has(key))
-        continue;
-      stopItem(key);
-      itemValues.set(key, value);
-      itemStops.set(key, fx(() => {
-        const current = read(key);
-        itemValues.set(key, current);
-        callback(current, key, node);
-      }));
-    }
-    for (const key of itemStops.keys()) {
-      if (!activeKeys.has(key))
-        stopItem(key);
-    }
-  });
-  const stop = () => {
-    if (disposed)
-      return;
-    disposed = true;
-    stopMembership();
-    for (const key of itemStops.keys())
-      stopItem(key);
-  };
-  if (scope)
-    scope.onDispose(stop);
-  return stop;
-  function stopItem(key) {
-    itemStops.get(key)?.();
-    itemStops.delete(key);
-    itemValues.delete(key);
-  }
-}
-
-// ../orbz/src/utils/createOrbFactory.js
-var { ORB_STATE, ORB_PLAN, ORB_GETTER_CACHE, FACTORY_PLAN } = MEM;
-var behaviorDepth = 0;
-var CONSTRUCT = Symbol("construct");
-var HYDRATE = Symbol("hydrate");
-function createOrbFactory(plan) {
-
-  class Orb {
-    constructor(input, mode = CONSTRUCT) {
-      ORB_PLAN.set(this, plan);
-      const state = createInitialState(plan);
-      ORB_STATE.set(this, state);
-      ORB_GETTER_CACHE.set(this, new Map);
-      defineInstanceStateAccessors(this, plan);
-      runWithBehaviorAuthority(() => {
-        const normalized = mode === HYDRATE ? normalizeHydrationInput(this, plan, input) : normalizeConstructorInput(this, plan, input);
-        applyConstructorInput(this, plan, normalized, {
-          hydration: mode === HYDRATE
-        });
-      });
-      MEM.BASE_ANCHOR.adoptRuntimeOrb(this);
-    }
-    toJSON() {
-      return this[VOCAB.SHAPE.SAVE]();
-    }
-  }
-  function OrbFactory(input) {
-    return new Orb(input);
-  }
-  Object.defineProperty(Orb, "name", {
-    value: sanitizeConstructorName(plan.id),
-    configurable: true
-  });
-  Object.defineProperty(Orb, "shapeId", {
-    value: plan.id,
-    enumerable: true
-  });
-  Object.defineProperty(Orb, "hydrate", {
-    enumerable: true,
-    configurable: false,
-    value(record) {
-      return hydrateOrb(Orb, plan, record);
-    }
-  });
-  Object.defineProperty(Orb, "accepts", {
-    enumerable: true,
-    configurable: false,
-    value(value) {
-      return acceptsShape(plan, value);
-    }
-  });
-  Object.defineProperty(OrbFactory, "name", {
-    value: sanitizeConstructorName(plan.id),
-    configurable: true
-  });
-  Object.defineProperty(OrbFactory, "prototype", {
-    value: Orb.prototype,
-    configurable: false
-  });
-  Object.defineProperty(OrbFactory, "shapeId", {
-    value: plan.id,
-    enumerable: true
-  });
-  Object.defineProperty(OrbFactory, "hydrate", {
-    enumerable: true,
-    configurable: false,
-    value(record) {
-      return hydrateOrb(Orb, plan, record);
-    }
-  });
-  Object.defineProperty(OrbFactory, "accepts", {
-    enumerable: true,
-    configurable: false,
-    value(value) {
-      return acceptsShape(plan, value);
-    }
-  });
-  FACTORY_PLAN.set(OrbFactory, plan);
-  Object.defineProperty(plan, "factory", {
-    value: OrbFactory,
-    enumerable: false,
-    configurable: true
-  });
-  for (const entry of plan.entries) {
-    switch (entry.kind) {
-      case "state":
-      case "slot":
-        defineStateAccessor(Orb.prototype, entry);
-        break;
-      case "getter":
-        defineGetter(Orb.prototype, entry);
-        break;
-      case "pairedAccessor":
-        definePairedAccessor(Orb.prototype, entry);
-        break;
-      case "shortcutSetter":
-        defineShortcutSetter(Orb.prototype, entry);
-        break;
-      case "method":
-        defineMethod(Orb.prototype, entry);
-        break;
-      case "generatorMethod":
-        defineGeneratorMethod(Orb.prototype, entry);
-        break;
-      default:
-        throw new Error(`Unknown Shape entry kind '${entry.kind}'`);
-    }
-  }
-  defineDollar(Orb.prototype);
-  defineProtocol(Orb.prototype, plan);
-  return OrbFactory;
-}
-function hydrateOrb(Orb, plan, record) {
-  const input = parseHydrationRecord(record, plan);
-  return new Orb(input, HYDRATE);
-}
-function parseHydrationRecord(record, plan) {
-  if (typeof record === "string") {
-    const parsed = JSON.parse(record);
-    if (plan.protocol.load) {
-      return parsed;
-    } else {
-      record = parsed;
-    }
-  }
-  if (plan.protocol.load) {
-    return record;
-  } else if (!record || typeof record !== "object" || Array.isArray(record)) {
-    throw new TypeError("Orb hydration record must be an object or JSON string");
-  } else {
-    return record;
-  }
-}
-function defineInstanceStateAccessors(orb, plan) {
-  for (const entry of plan.state) {
-    defineStateAccessor(orb, entry);
-  }
-}
-function createInitialState(plan) {
-  const state = {};
-  for (const entry of plan.state) {
-    state[entry.key] = entry.kind === "slot" ? undefined : cloneDefault(entry.value);
-  }
-  return state;
-}
-function applyConstructorInput(orb, plan, input, options = {}) {
-  if (input == null) {
-    assertRequiredSlots(orb, plan);
-    return;
-  }
-  if (typeof input !== "object") {
-    throw new TypeError("Orb constructor input must be an object");
-  }
-  for (const [key, value] of Object.entries(input)) {
-    const entry = plan.byKey.get(key);
-    if (!entry) {
-      throw new Error(`Unknown constructor key '${key}' for Shape '${plan.id}'`);
-    }
-    switch (entry.kind) {
-      case "state":
-      case "slot":
-        if (value instanceof OrbLink) {
-          const state = getState(orb);
-          state[key] = value;
-          value.bindOrb(orb, key);
-          markStateChanged(orb, key);
-        } else {
-          orb[key] = value;
-        }
-        break;
-      case "pairedAccessor":
-      case "shortcutSetter":
-        orb[key] = value;
-        break;
-      case "getter":
-        throw new Error(`Cannot assign derived getter '${key}' during construction`);
-      case "method":
-      case "generatorMethod":
-        throw new Error(`Cannot assign method '${key}' during construction`);
-      default:
-        throw new Error(`Unsupported constructor key '${key}'`);
-    }
-  }
-  assertRequiredSlots(orb, plan);
-  if (options.hydration) {
-    for (const key of Object.keys(input)) {
-      const entry = plan.byKey.get(key);
-      if (entry?.meta?.serializable)
-        continue;
-      throw new Error(`Hydration key '${key}' is not persisted state`);
-    }
-  }
-}
-function normalizeConstructorInput(orb, plan, input) {
-  const normalized = (plan.protocol.init ?? defaultInit).call(orb, input);
-  if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
-    throw new TypeError("Shape.init must return constructor state");
-  }
-  return normalized;
-}
-function normalizeHydrationInput(orb, plan, input) {
-  const normalized = (plan.protocol.load ?? defaultLoad).call(orb, input);
-  if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
-    throw new TypeError("Shape.load must return constructor state");
-  }
-  return normalized;
-}
-function serializeDefaultOrb(orb, plan) {
-  const state = getState(orb);
-  const out = {};
-  for (const entry of plan.serializable) {
-    out[entry.key] = serializeSlot(state[entry.key]);
-  }
-  return out;
-}
-function defaultInit(input = {}) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    throw new TypeError("Orb constructor input must be an object");
-  }
-  return input;
-}
-function defaultLoad(input = {}) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    throw new TypeError("Orb hydration record must be an object or JSON string");
-  }
-  return input;
-}
-function defineStateAccessor(proto, entry) {
-  Object.defineProperty(proto, entry.key, {
-    enumerable: entry.meta.enumerable,
-    configurable: false,
-    get() {
-      const state = getState(this);
-      if (entry.meta.internal && !hasBehaviorAuthority()) {
-        throw new Error(`Cannot read internal state '${entry.key}' from outside Shape behavior`);
-      }
-      trackDependency(this, entry.key);
-      return readSlot(state[entry.key]);
-    },
-    set(value) {
-      if (entry.meta.internal && !hasBehaviorAuthority()) {
-        throw new Error(`Cannot write internal state '${entry.key}' from outside Shape behavior`);
-      }
-      const state = getState(this);
-      const previous = state[entry.key];
-      if (previous instanceof OrbLink) {
-        throw new Error(`Cannot write linked state slot '${entry.key}'`);
-      }
-      state[entry.key] = prepareStateValue(this, entry, value);
-      if (!Object.is(previous, value)) {
-        batch(() => {
-          emitOrbEvent(this, "state:write", entry.key);
-          markStateChanged(this, entry.key);
-          const meta = MEM.ORB_META.get(this);
-          meta?.anchor?.handleOrbSlotChanged?.(this, entry.key);
-        });
-      }
-    }
-  });
-}
-function prepareStateValue(orb, entry, value) {
-  if (entry.kind === "slot") {
-    assertSlotValue(entry, value);
-  }
-  return value;
-}
-function assertRequiredSlots(orb, plan) {
-  const state = getState(orb);
-  for (const entry of plan.slots) {
-    if (state[entry.key] === undefined) {
-      throw new Error(`Missing required slot '${entry.key}'`);
-    }
-  }
-}
-function assertSlotValue(entry, value) {
-  if (value instanceof OrbLink)
-    return;
-  if (value instanceof LazyRef)
-    return;
-  if (!entry.value.accepts(value)) {
-    throw new Error(`Slot '${entry.key}' expects Shape '${entry.shapeId}'`);
-  }
-}
-function defineGetter(proto, entry) {
-  Object.defineProperty(proto, entry.key, {
-    enumerable: false,
-    configurable: false,
-    get() {
-      return readCachedGetter(this, entry);
-    }
-  });
-}
-function definePairedAccessor(proto, entry) {
-  Object.defineProperty(proto, entry.key, {
-    enumerable: false,
-    configurable: false,
-    get() {
-      return readCachedGetter(this, entry);
-    },
-    set(value) {
-      return batch(() => runWithBehaviorAuthority(() => entry.set.call(this, value)));
-    }
-  });
-}
-function defineShortcutSetter(proto, entry) {
-  Object.defineProperty(proto, entry.key, {
-    enumerable: false,
-    configurable: false,
-    get() {
-      return;
-    },
-    set(value) {
-      return batch(() => runWithBehaviorAuthority(() => entry.set.call(this, value)));
-    }
-  });
-}
-function defineMethod(proto, entry) {
-  Object.defineProperty(proto, entry.key, {
-    enumerable: false,
-    configurable: false,
-    value(...args) {
-      return batch(() => runWithBehaviorAuthority(() => entry.value.apply(this, args)));
-    }
-  });
-}
-function defineGeneratorMethod(proto, entry) {
-  Object.defineProperty(proto, entry.key, {
-    enumerable: false,
-    configurable: false,
-    value(...args) {
-      const iterator = runWithBehaviorAuthority(() => entry.value.apply(this, args));
-      return runGeneratorFlow(iterator);
-    }
-  });
-}
-function defineDollar(proto) {
-  Object.defineProperty(proto, "$", {
-    enumerable: false,
-    configurable: false,
-    get() {
-      const orb = this;
-      function createLink(key) {
-        if (typeof key !== "string") {
-          throw new TypeError("orb.$() expects a property key string in v1");
-        }
-        const plan = ORB_PLAN.get(orb);
-        if (!plan.byKey.has(key)) {
-          throw new Error(`Cannot create link to unknown key '${key}'`);
-        }
-        const entry = plan.byKey.get(key);
-        if (!isPublicReadableEntry(entry)) {
-          throw new Error(`Cannot create link to unreadable key '${key}'`);
-        }
-        return new OrbLink(orb, key, { $: `${getOrbId(orb)}/${key}` });
-      }
-      Object.defineProperty(createLink, "uuid", {
-        enumerable: true,
-        configurable: true,
-        get() {
-          return MEM.ORB_META.get(orb)?.uuid ?? getOrbRuntimeId2(orb);
-        }
-      });
-      Object.defineProperty(createLink, "anchor", {
-        enumerable: true,
-        configurable: true,
-        get() {
-          return MEM.ORB_META.get(orb)?.anchor;
-        }
-      });
-      Object.defineProperty(createLink, "routes", {
-        enumerable: true,
-        configurable: true,
-        get() {
-          return [...MEM.ORB_META.get(orb)?.routes ?? []];
-        }
-      });
-      Object.defineProperty(createLink, "mount", {
-        enumerable: true,
-        configurable: true,
-        get() {
-          return createMountApi(orb);
-        }
-      });
-      Object.defineProperty(createLink, "track", {
-        enumerable: true,
-        configurable: true,
-        value(token) {
-          assertBehaviorAuthority("track");
-          trackDependency(orb, token);
-        }
-      });
-      Object.defineProperty(createLink, "changed", {
-        enumerable: true,
-        configurable: true,
-        value(token) {
-          assertBehaviorAuthority("changed");
-          markStateChanged(orb, token);
-          const meta = MEM.ORB_META.get(orb);
-          meta?.anchor?.handleOrbProtocolChanged?.(orb, token);
-        }
-      });
-      return createLink;
-    }
-  });
-}
-function createMountApi(orb) {
-  return {
-    get info() {
-      return cloneMountInfo(MEM.MOUNTS.get(orb));
-    },
-    status(key) {
-      return readMountBackingState(orb, "_mount_statuses", key);
-    },
-    error(key) {
-      return readMountBackingState(orb, "_mount_errors", key);
-    },
-    apply(patch = {}) {
-      return applyMountPatch(orb, patch);
-    }
-  };
-}
-function applyMountPatch(orb, patch = {}) {
-  const runtime = MEM.MOUNTS.get(orb);
-  if (!runtime)
-    return;
-  const apply = orb?._mountApply;
-  if (typeof apply !== "function") {
-    throw new Error("Mounted orb is missing generated _mountApply()");
-  }
-  return apply.call(orb, patch);
-}
-function readMountBackingState(orb, stateKey, key) {
-  if (!MEM.MOUNTS.has(orb))
-    return;
-  const values = runWithBehaviorAuthority(() => orb[stateKey]);
-  if (key === undefined)
-    return values;
-  return values?.[key];
-}
-function cloneMountInfo(runtime) {
-  if (!runtime)
-    return;
-  return {
-    source: { ...runtime.source },
-    target: runtime.target,
-    shape: { ...runtime.shape },
-    outsource: [...runtime.outsource],
-    projections: [...runtime.projections],
-    commands: [...runtime.commands]
-  };
-}
-function defineProtocol(proto, plan) {
-  const protocol = {
-    [VOCAB.SHAPE.KEYS]: plan.protocol.keys ?? defaultKeys,
-    [VOCAB.SHAPE.EDGE]: plan.protocol.edge ?? defaultEdge,
-    [VOCAB.SHAPE.SAVE]: plan.protocol.save ?? defaultSave,
-    [VOCAB.SHAPE.LOAD]: plan.protocol.load ?? defaultLoad,
-    [VOCAB.SHAPE.INIT]: plan.protocol.init ?? defaultInit
-  };
-  defineProtocolMethod(proto, VOCAB.SHAPE.INIT, protocol[VOCAB.SHAPE.INIT]);
-  defineProtocolMethod(proto, VOCAB.SHAPE.KEYS, protocol[VOCAB.SHAPE.KEYS]);
-  defineProtocolMethod(proto, VOCAB.SHAPE.EDGE, protocol[VOCAB.SHAPE.EDGE]);
-  defineProtocolMethod(proto, VOCAB.SHAPE.SAVE, protocol[VOCAB.SHAPE.SAVE]);
-  defineProtocolMethod(proto, VOCAB.SHAPE.LOAD, protocol[VOCAB.SHAPE.LOAD]);
-  function defaultKeys() {
-    return plan.serializable.map((entry) => entry.key);
-  }
-  function defaultEdge(key) {
-    const entry = plan.byKey.get(key);
-    if (!entry || !entry.meta.serializable) {
-      throw new Error(`Unknown edge '${String(key)}'`);
-    }
-    const orb = this;
-    const state = getState(orb);
-    return {
-      key,
-      segment: String(key),
-      read() {
-        trackDependency(orb, key);
-        return readSlot(state[key]);
-      },
-      peek() {
-        return state[key];
-      },
-      write(value) {
-        return runWithBehaviorAuthority(() => {
-          orb[key] = value;
-          return value;
-        });
-      }
-    };
-  }
-  function defaultSave() {
-    return serializeDefaultOrb(this, plan);
-  }
-}
-function defineProtocolMethod(proto, symbol, method) {
-  Object.defineProperty(proto, symbol, {
-    enumerable: false,
-    configurable: false,
-    value(...args) {
-      return runWithBehaviorAuthority(() => {
-        const result = method.apply(this, args);
-        return symbol === VOCAB.SHAPE.EDGE ? wrapEdgeBehavior(result) : result;
-      });
-    }
-  });
-}
-function wrapEdgeBehavior(edge) {
-  if (!edge || typeof edge !== "object") {
-    return edge;
-  }
-  const wrapped = { ...edge };
-  for (const key of Reflect.ownKeys(wrapped)) {
-    if (typeof wrapped[key] !== "function")
-      continue;
-    const method = wrapped[key];
-    wrapped[key] = function edgeBehaviorMethod(...args) {
-      const run = () => runWithBehaviorAuthority(() => method.apply(edge, args));
-      return key === "write" || key === "delete" ? batch(run) : run();
-    };
-  }
-  return wrapped;
-}
-function isPublicReadableEntry(entry) {
-  if (entry.meta.internal)
-    return false;
-  return entry.kind === "state" || entry.kind === "getter" || entry.kind === "pairedAccessor";
-}
-function readCachedGetter(orb, entry) {
-  trackDependency(orb, entry.key);
-  const cache = getGetterCache(orb, entry.key);
-  if (cache.hasValue && !cache.dirty) {
-    emitOrbEvent(orb, "getter:cache-hit", entry.key);
-    return cache.value;
-  }
-  const computation = getGetterComputation(orb, entry.key);
-  try {
-    emitOrbEvent(orb, "getter:compute", entry.key);
-    const value = runTracked(computation, () => runWithBehaviorAuthority(() => entry.get.call(orb)));
-    cache.value = wrapBehaviorFunction(value, orb);
-    replaceSubscriptions(computation);
-    cache.deps = computation.deps;
-    cache.dirty = false;
-    cache.hasValue = true;
-    return cache.value;
-  } catch (error) {
-    replaceSubscriptions(computation);
-    cache.deps = computation.deps;
-    cache.dirty = true;
-    cache.hasValue = false;
-    throw error;
-  }
-}
-function wrapBehaviorFunction(value, orb) {
-  if (typeof value !== "function")
-    return value;
-  return function behaviorFunction(...args) {
-    return runWithBehaviorAuthority(() => value.apply(orb, args));
-  };
-}
-function getGetterCache(orb, key) {
-  const getterCache = ORB_GETTER_CACHE.get(orb);
-  if (!getterCache) {
-    throw new Error("Invalid Orb receiver");
-  }
-  if (!getterCache.has(key)) {
-    getterCache.set(key, {
-      value: undefined,
-      deps: new Set,
-      dirty: true,
-      hasValue: false,
-      computation: {
-        type: "getter",
-        orb,
-        key,
-        deps: new Set,
-        nextDeps: new Set,
-        onDependencyChanged() {
-          markGetterDirty(orb, key);
-        }
-      }
-    });
-  }
-  return getterCache.get(key);
-}
-function getGetterComputation(orb, key) {
-  return getGetterCache(orb, key).computation;
-}
-function markGetterDependentsDirty(orb, changedKey) {
-  const getterCache = ORB_GETTER_CACHE.get(orb);
-  if (!getterCache)
-    return;
-  const changedDependency = createDependencyKey(orb, changedKey);
-  for (const [getterKey, cache] of getterCache) {
-    if (cache.deps.has(changedDependency)) {
-      markGetterDirty(orb, getterKey);
-    }
-  }
-}
-function markGetterDirty(orb, getterKey) {
-  const cache = getGetterCache(orb, getterKey);
-  if (cache.dirty) {
-    emitOrbEvent(orb, "getter:dirty", getterKey);
-    notifyDependencyChanged(orb, getterKey);
-    propagateLinkedState(orb, getterKey);
-    return;
-  }
-  cache.dirty = true;
-  emitOrbEvent(orb, "getter:dirty", getterKey);
-  notifyDependencyChanged(orb, getterKey);
-  propagateLinkedState(orb, getterKey);
-  markGetterDependentsDirty(orb, getterKey);
-}
-function markStateChanged(orb, key) {
-  markGetterDependentsDirty(orb, key);
-  notifyDependencyChanged(orb, key);
-  propagateLinkedState(orb, key);
-}
-function propagateLinkedState(source, sourceKey) {
-  for (const { target, key } of OrbLink.linkedTargets(source, sourceKey)) {
-    markStateChanged(target, key);
-  }
-}
-function runGeneratorFlow(iterator) {
-  return new Promise((resolve, reject) => {
-    function step(method, value) {
-      let result;
-      try {
-        result = batch(() => runWithBehaviorAuthority(() => iterator[method](value)));
-      } catch (error) {
-        reject(error);
-        return;
-      }
-      if (result.done) {
-        resolve(result.value);
-        return;
-      }
-      Promise.resolve(result.value).then((value2) => step("next", value2), (error) => step("throw", error));
-    }
-    step("next");
-  });
-}
-function runWithBehaviorAuthority(fn) {
-  behaviorDepth++;
-  try {
-    return fn();
-  } finally {
-    behaviorDepth--;
-  }
-}
-function hasBehaviorAuthority() {
-  return behaviorDepth > 0;
-}
-function assertBehaviorAuthority(method) {
-  if (!hasBehaviorAuthority()) {
-    throw new Error(`node.$.${method}() may only be called from Shape behavior`);
-  }
-}
-function getState(orb) {
-  const state = ORB_STATE.get(orb);
-  if (!state) {
-    throw new Error("Invalid Orb receiver");
-  }
-  return state;
-}
-function emitOrbEvent(orb, type, key) {
-  emitInspectionEvent({ type, key, shapeId: ORB_PLAN.get(orb)?.id });
-}
-function cloneDefault(value) {
-  if (value === undefined)
-    return;
-  return JSON.parse(JSON.stringify(value));
-}
-function sanitizeConstructorName(shapeId) {
-  const name = shapeId.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^[a-zA-Z_$]/.test(name)) {
-    return name;
-  }
-  return `Shape_${name}`;
-}
-function getOrbId(orb) {
-  return `$uuid:${getOrbRuntimeId2(orb)}`;
-}
-var nextRuntimeOrbId2 = 1;
-var ORB_RUNTIME_ID2 = new WeakMap;
-function getOrbRuntimeId2(orb) {
-  if (!ORB_RUNTIME_ID2.has(orb)) {
-    ORB_RUNTIME_ID2.set(orb, nextRuntimeOrbId2++);
-  }
-  return ORB_RUNTIME_ID2.get(orb);
-}
-function acceptsShape(expectedPlan, value) {
-  const valuePlan = FACTORY_PLAN.get(value) ?? ORB_PLAN.get(value);
-  if (!valuePlan)
-    return false;
-  return valuePlan.id === expectedPlan.id || valuePlan.ancestryIds.has(expectedPlan.id);
-}
-function resolveLazyRef(orb, key, value) {
-  const plan = ORB_PLAN.get(orb);
-  const entry = plan?.byKey.get(key);
-  if (!entry || !entry.meta?.serializable) {
-    return resolveProtocolLazyRef(orb, key, value);
-  }
-  const state = ORB_STATE.get(orb);
-  if (!state) {
-    throw new Error("Invalid Orb receiver");
-  }
-  if (!(state[key] instanceof LazyRef)) {
-    throw new Error(`Slot '${key}' is not a lazy ref`);
-  }
-  state[key] = prepareStateValue(orb, entry, value);
-  batch(() => {
-    emitOrbEvent(orb, "state:write", key);
-    markStateChanged(orb, key);
-    const meta = MEM.ORB_META.get(orb);
-    meta?.anchor?.handleOrbSlotChanged?.(orb, key);
-  });
-  return value;
-}
-function resolveProtocolLazyRef(orb, key, value) {
-  const edge = orb[VOCAB.SHAPE.EDGE](key);
-  const current = edge.peek();
-  if (current !== undefined && !(current instanceof LazyRef)) {
-    throw new Error(`Protocol edge '${key}' is not a lazy ref`);
-  }
-  edge.write(value);
-  return value;
-}
-
-class OrbLink {
-  constructor(source, key, descriptor) {
-    this.source = source;
-    this.key = key;
-    this.descriptor = descriptor;
-  }
-  read() {
-    return this.source[this.key];
-  }
-  serialize() {
-    return this.descriptor;
-  }
-  target() {
-    return { source: this.source, key: this.key };
-  }
-  bindOrb(target, key) {
-    const dependency = createDependencyKey(this.source, this.key);
-    let targets = MEM.LINKS_BY_SOURCE.get(dependency);
-    if (!targets) {
-      targets = new Set;
-      MEM.LINKS_BY_SOURCE.set(dependency, targets);
-    }
-    targets.add({ target, key });
-  }
-  static linkedTargets(source, key) {
-    const targets = MEM.LINKS_BY_SOURCE.get(createDependencyKey(source, key));
-    return targets ? [...targets] : [];
-  }
-}
-
-class LazyRef {
-  constructor(ref) {
-    if (typeof ref !== "string" || ref.length === 0) {
-      throw new TypeError("LazyRef expects a non-empty ref string");
-    }
-    this.ref = ref;
-    this.status = "idle";
-  }
-}
-function readSlot(value) {
-  if (value instanceof OrbLink)
-    return value.read();
-  if (value instanceof LazyRef)
-    return;
-  return value;
-}
-function serializeSlot(value) {
-  if (value instanceof OrbLink)
-    return value.serialize();
-  if (value instanceof LazyRef)
-    return { $: value.ref };
-  return value;
-}
-
-// ../orbz/src/Shape.js
-function Shape(...defs) {
-  if (defs.length < 1) {
-    throw new TypeError("Shape() expects a definition object");
-  }
-  const finalDefinition = defs.at(-1);
-  const parents = defs.slice(0, -1);
-  if (parents.length === 0) {
-    const plan2 = createShapePlan(finalDefinition);
-    return createOrbFactory(plan2);
-  }
-  const parentPlans = parents.map((parent) => {
-    const plan2 = MEM.FACTORY_PLAN.get(parent);
-    if (!plan2) {
-      throw new TypeError("Shape extension parents must be Shape factories");
-    }
-    return plan2;
-  });
-  const extendedDefinition = createExtendedShapeDefinition(parentPlans, finalDefinition);
-  const plan = createShapePlan(extendedDefinition, { parents: parentPlans });
-  return createOrbFactory(plan);
-}
-Object.defineProperties(Shape, {
-  name: { value: VOCAB.SHAPE.NAME, enumerable: true, configurable: true },
-  init: { value: VOCAB.SHAPE.INIT, enumerable: true },
-  keys: { value: VOCAB.SHAPE.KEYS, enumerable: true },
-  edge: { value: VOCAB.SHAPE.EDGE, enumerable: true },
-  save: { value: VOCAB.SHAPE.SAVE, enumerable: true },
-  load: { value: VOCAB.SHAPE.LOAD, enumerable: true },
-  mounts: { value: VOCAB.SHAPE.MOUNTS, enumerable: true }
-});
-// ../orbz/src/libShapes/Mount.js
-var MOUNT_RESERVED_KEYS = new Set([
-  "_mount_values",
-  "_mount_statuses",
-  "_mount_errors",
-  "_mount_logs",
-  "_mountApply",
-  "_mountDispose"
-]);
-var FACTORY_CACHE = new WeakMap;
-function createMountedFactory(SourceShape, target) {
-  const sourcePlan = MEM.FACTORY_PLAN.get(SourceShape);
-  if (!sourcePlan)
-    throw new TypeError("createMountedFactory() expects a Shape factory");
-  const mount = sourcePlan.mounts?.[target];
-  if (!mount)
-    return null;
-  let byTarget = FACTORY_CACHE.get(SourceShape);
-  if (!byTarget) {
-    byTarget = new Map;
-    FACTORY_CACHE.set(SourceShape, byTarget);
-  }
-  if (byTarget.has(target))
-    return byTarget.get(target);
-  assertOrdinarySourceShape(sourcePlan);
-  assertReservedKeysAvailable(sourcePlan);
-  const mountedName = `${sourcePlan.name}$mount$${target}`;
-  const definition = createMountDefinition(sourcePlan, {
-    target,
-    name: mountedName,
-    source: {
-      id: sourcePlan.id,
-      name: sourcePlan.name
-    },
-    outsource: mount.outsource,
-    projections: mount.projections,
-    commands: mount.commands
-  });
-  const MountedShape = Shape(SourceShape, definition);
-  MEM.MOUNT_FACTORIES.set(MountedShape, {
-    sourceFactory: SourceShape,
-    source: {
-      id: sourcePlan.id,
-      name: sourcePlan.name
-    },
-    sourcePlan,
-    target,
-    shape: {
-      id: mountedName,
-      name: mountedName
-    },
-    outsource: [...mount.outsource],
-    projections: [...mount.projections],
-    commands: [...mount.commands]
-  });
-  byTarget.set(target, MountedShape);
-  return MountedShape;
-}
-function isMountedOrb(value) {
-  return MEM.MOUNTS.has(value);
-}
-function getMountSourcePlan(orb) {
-  return MEM.MOUNTS.get(orb)?.sourcePlan;
-}
-function bindMountedOrb(anchor, orb) {
-  const runtime = MEM.MOUNTS.get(orb);
-  if (!runtime)
-    return;
-  const routes = [...MEM.ORB_META.get(orb)?.routes ?? []];
-  const contextKey = `${anchor.id}:${routes.join("|")}`;
-  if (runtime.anchor === anchor && runtime.contextKey === contextKey)
-    return;
-  runtime.unsubscribe?.();
-  runtime.anchor = anchor;
-  runtime.contextKey = contextKey;
-  runtime.routes = routes;
-  runtime.unsubscribe = undefined;
-  if (routes.length === 0)
-    return;
-  const subscribe = anchor.adapter.mount?.subscribe;
-  if (typeof subscribe !== "function") {
-    applyMountPatch2(orb, {
-      statuses: Object.fromEntries(runtime.projections.map((key) => [key, "pending"]))
-    });
-    return;
-  }
-  const unsubscribe = subscribe.call(anchor.adapter.mount, createMountContext(anchor, orb, runtime), (patch) => applyMountPatch2(orb, patch));
-  runtime.unsubscribe = typeof unsubscribe === "function" ? unsubscribe : undefined;
-}
-function disposeMountedOrb(orb) {
-  const runtime = MEM.MOUNTS.get(orb);
-  if (!runtime)
-    return;
-  runtime.unsubscribe?.();
-  runtime.unsubscribe = undefined;
-  runtime.anchor = null;
-  MEM.MOUNTS.delete(orb);
-  return;
-}
-function commandMountedOrb(orb, method, args) {
-  const runtime = MEM.MOUNTS.get(orb);
-  if (!runtime) {
-    throw new Error(`Cannot call mounted method '${method}' on a non-mounted Orb`);
-  }
-  const anchor = runtime.anchor ?? MEM.ORB_META.get(orb)?.anchor;
-  const command = anchor?.adapter.mount?.command;
-  if (typeof command !== "function") {
-    throw new Error(`Mounted method '${method}' requires an Anchor mount adapter`);
-  }
-  return command.call(anchor.adapter.mount, createMountContext(anchor, orb, runtime), method, args);
-}
-function applyMountPatch2(orb, patch = {}) {
-  const runtime = MEM.MOUNTS.get(orb);
-  if (!runtime)
-    return;
-  const normalized = normalizePatch(patch);
-  const apply = orb?._mountApply;
-  if (typeof apply !== "function") {
-    throw new Error("Mounted orb is missing generated _mountApply()");
-  }
-  return apply.call(orb, normalized);
-}
-function createMountDefinition(sourcePlan, config) {
-  const projections = new Set(config.projections);
-  const commands = new Set(config.commands);
-  const definition = {};
-  Object.defineProperty(definition, VOCAB.SHAPE.NAME, {
-    value: config.name,
-    enumerable: true,
-    configurable: true
-  });
-  for (const key of projections) {
-    const descriptor = sourcePlan.descriptors[key];
-    Object.defineProperty(definition, key, {
-      get() {
-        return this._mount_values[key];
-      },
-      enumerable: descriptor.enumerable,
-      configurable: descriptor.configurable
-    });
-  }
-  for (const key of commands) {
-    const descriptor = sourcePlan.descriptors[key];
-    Object.defineProperty(definition, key, {
-      value(...args) {
-        return commandMountedOrb(this, key, args);
-      },
-      enumerable: descriptor.enumerable,
-      configurable: descriptor.configurable,
-      writable: descriptor.writable
-    });
-  }
-  defineMountState(definition);
-  defineGeneratedMethod(definition, "_mountApply", mountApplyBehavior);
-  defineGeneratedMethod(definition, "_mountDispose", mountDisposeBehavior);
-  defineMountProtocol(definition, sourcePlan);
-  Object.defineProperty(definition, VOCAB.SHAPE.INIT, {
-    value(input = {}) {
-      initializeMountRuntime(this, config);
-      return normalizeConstructorState(input, "Orb constructor input");
-    },
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-  Object.defineProperty(definition, VOCAB.SHAPE.LOAD, {
-    value(input = {}) {
-      initializeMountRuntime(this, config);
-      return normalizeConstructorState(input, "Orb hydration record");
-    },
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-  return definition;
-}
-function defineMountProtocol(definition, sourcePlan) {
-  const sourceKeys = sourcePlan.serializable.map((entry) => entry.key);
-  const sourceKeySet = new Set(sourceKeys);
-  Object.defineProperty(definition, VOCAB.SHAPE.KEYS, {
-    value() {
-      return [...sourceKeys];
-    },
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-  Object.defineProperty(definition, VOCAB.SHAPE.EDGE, {
-    value(key) {
-      if (!sourceKeySet.has(key)) {
-        throw new Error(`Unknown mount edge '${String(key)}'`);
-      }
-      return {
-        key,
-        segment: String(key),
-        read: () => this[key],
-        peek: () => this[key],
-        write: (value) => {
-          this[key] = value;
-          return value;
-        }
-      };
-    },
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-  Object.defineProperty(definition, VOCAB.SHAPE.SAVE, {
-    value() {
-      const out = {};
-      for (const key of sourceKeys) {
-        out[key] = this[key];
-      }
-      return out;
-    },
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-}
-function defineMountState(definition) {
-  Object.defineProperties(definition, {
-    _mount_values: {
-      value: {},
-      enumerable: true,
-      configurable: true,
-      writable: true
-    },
-    _mount_statuses: {
-      value: {},
-      enumerable: true,
-      configurable: true,
-      writable: true
-    },
-    _mount_errors: {
-      value: {},
-      enumerable: true,
-      configurable: true,
-      writable: true
-    },
-    _mount_logs: {
-      value: [],
-      enumerable: true,
-      configurable: true,
-      writable: true
-    }
-  });
-}
-function defineGeneratedMethod(definition, key, value) {
-  Object.defineProperty(definition, key, {
-    value,
-    enumerable: false,
-    configurable: true,
-    writable: true
-  });
-}
-function initializeMountRuntime(orb, config) {
-  MEM.MOUNTS.set(orb, {
-    source: config.source,
-    sourcePlan: null,
-    target: config.target,
-    shape: {
-      id: config.name,
-      name: config.name
-    },
-    outsource: [...config.outsource],
-    projections: [...config.projections],
-    commands: [...config.commands],
-    anchor: null,
-    routes: [],
-    contextKey: "",
-    unsubscribe: undefined
-  });
-  const factoryInfo = MEM.MOUNT_FACTORIES.get(MEM.ORB_PLAN.get(orb)?.factory);
-  const runtime = MEM.MOUNTS.get(orb);
-  if (factoryInfo) {
-    runtime.sourcePlan = factoryInfo.sourcePlan;
-  }
-}
-function mountApplyBehavior(patch = {}) {
-  const normalized = normalizePatch(patch);
-  if (normalized.values) {
-    this._mount_values = {
-      ...readObjectState(this._mount_values),
-      ...normalized.values
-    };
-  }
-  if (normalized.statuses) {
-    this._mount_statuses = {
-      ...readObjectState(this._mount_statuses),
-      ...normalized.statuses
-    };
-  }
-  if (normalized.errors) {
-    this._mount_errors = {
-      ...readObjectState(this._mount_errors),
-      ...normalized.errors
-    };
-  }
-  if (normalized.logs) {
-    this._mount_logs = [
-      ...readArrayState(this._mount_logs),
-      ...normalized.logs
-    ];
-  }
-  return this;
-}
-function mountDisposeBehavior() {
-  return disposeMountedOrb(this);
-}
-function createMountContext(anchor, orb, runtime) {
-  const meta = MEM.ORB_META.get(orb);
-  return {
-    anchor,
-    anchorId: anchor.id,
-    orb,
-    uuid: meta?.uuid,
-    routes: [...meta?.routes ?? []],
-    sourceShape: { ...runtime.source },
-    mountShape: { ...runtime.shape },
-    target: runtime.target,
-    outsource: [...runtime.outsource],
-    projections: [...runtime.projections],
-    commands: [...runtime.commands]
-  };
-}
-function normalizePatch(patch) {
-  if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
-    throw new TypeError("Mount patch must be an object");
-  }
-  const normalized = {};
-  if (patch.values !== undefined) {
-    assertPlainObject(patch.values, "Mount patch values");
-    normalized.values = patch.values;
-  }
-  if (patch.statuses !== undefined) {
-    assertPlainObject(patch.statuses, "Mount patch statuses");
-    for (const [key, value] of Object.entries(patch.statuses)) {
-      if (typeof value !== "string") {
-        throw new TypeError(`Mount patch status '${key}' must be a string`);
-      }
-    }
-    normalized.statuses = patch.statuses;
-  }
-  if (patch.errors !== undefined) {
-    assertPlainObject(patch.errors, "Mount patch errors");
-    normalized.errors = patch.errors;
-  }
-  if (patch.logs !== undefined) {
-    if (!Array.isArray(patch.logs)) {
-      throw new TypeError("Mount patch logs must be an array");
-    }
-    normalized.logs = patch.logs;
-  }
-  return normalized;
-}
-function normalizeConstructorState(input, label) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    throw new TypeError(`${label} must be an object`);
-  }
-  return input;
-}
-function readObjectState(value) {
-  if (value && typeof value === "object" && !Array.isArray(value))
-    return value;
-  return {};
-}
-function readArrayState(value) {
-  if (Array.isArray(value))
-    return value;
-  return [];
-}
-function assertOrdinarySourceShape(sourcePlan) {
-  for (const symbol of VOCAB.SHAPE_SYMBOLS) {
-    if (symbol !== VOCAB.SHAPE.NAME && symbol !== VOCAB.SHAPE.MOUNTS && sourcePlan.protocol[protocolKey(symbol)]) {
-      throw new Error(`Mount only supports ordinary Shapes (Shape '${sourcePlan.id}')`);
-    }
-  }
-}
-function protocolKey(symbol) {
-  if (symbol === VOCAB.SHAPE.INIT)
-    return "init";
-  if (symbol === VOCAB.SHAPE.KEYS)
-    return "keys";
-  if (symbol === VOCAB.SHAPE.EDGE)
-    return "edge";
-  if (symbol === VOCAB.SHAPE.SAVE)
-    return "save";
-  if (symbol === VOCAB.SHAPE.LOAD)
-    return "load";
-  throw new Error("Unknown Shape protocol symbol");
-}
-function assertReservedKeysAvailable(sourcePlan) {
-  for (const key of MOUNT_RESERVED_KEYS) {
-    if (sourcePlan.byKey.has(key)) {
-      throw new Error(`Cannot mount Shape '${sourcePlan.id}' because '${key}' is reserved for Mount`);
-    }
-  }
-}
-function assertPlainObject(value, label) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new TypeError(`${label} must be an object`);
-  }
-}
-
-// ../orbz/src/Anchor.js
-class Anchor {
-  constructor(options = {}) {
-    const normalized = typeof options === "string" ? { id: options } : options;
-    this.id = normalized.id ?? `anchor${MEM.LAST_ANCHOR_ID++}`;
-    this._connections = new Map;
-    this._uuidToOrb = new Map;
-    this._routeToUuid = new Map;
-    this._observers = new Set;
-    this._nextUuid = 1;
-    this.adapter = normalized.adapter ?? createMemoryAdapter();
-    this.loading = normalized.loading ?? "eager";
-    this.mountTargets = normalizeMountTargets(normalized.mountTargets ?? normalized.mountTarget);
-    this._resolveAnchor = normalized.resolveAnchor ?? null;
-    this._dirty = new Set;
-    this._deletedRoutes = new Set;
-    this._pendingLazyByUuid = new Map;
-    this._disposed = false;
-    this._autosaveRunning = false;
-    this._autosaveTimer = null;
-    if (normalized.autosave) {
-      this._startAutosave(normalized.autosave);
-    }
-  }
-  connect(anchor) {
-    if (!anchor || typeof anchor.id !== "string") {
-      throw new TypeError("connect() expects an Anchor");
-    }
-    if (hasSharedAnchorId(this, anchor)) {
-      throw new Error(`Anchor '${anchor.id}' is already connected`);
-    }
-    this._connections.set(anchor.id, anchor);
-  }
-  observe(listener) {
-    if (typeof listener !== "function") {
-      throw new TypeError("Anchor.observe() expects a listener function");
-    }
-    this._observers.add(listener);
-    let active = true;
-    return () => {
-      if (!active)
-        return;
-      active = false;
-      this._observers.delete(listener);
-    };
-  }
-  adoptRuntimeOrb(orb) {
-    return this._ensureOrb(orb);
-  }
-  resolveMount(shapeFactory) {
-    if (typeof shapeFactory !== "function") {
-      throw new TypeError("Anchor.resolveMount() expects a Shape factory");
-    }
-    for (const target of this.mountTargets) {
-      const mounted = createMountedFactory(shapeFactory, target);
-      if (mounted)
-        return mounted;
-    }
-    return;
-  }
-  set(route, orb) {
-    assertRoute(route);
-    return this._adoptValueAtRoute(route, orb) || orb;
-  }
-  handleOrbSlotChanged(orb, key) {
-    const meta = MEM.ORB_META.get(orb);
-    if (meta?.anchor === this) {
-      this._dirty.add(meta.uuid);
-      const shape = MEM.ORB_PLAN.get(orb)?.id;
-      const edge = getEdge(orb, key);
-      if (!edge) {
-        for (const route of meta.routes) {
-          this._deriveOrbRoutes(orb, route);
-        }
-        return;
-      }
-      this._emitObserve({
-        type: "state:write",
-        uuid: meta.uuid,
-        shape,
-        key,
-        value: this._serializeValue(edge.peek()),
-        routes: [...meta.routes]
-      });
-      for (const route of meta.routes) {
-        const edgeRoute = joinRoute(route, edge.segment);
-        if (!this._adoptValueAtRoute(edgeRoute, edge.peek())) {
-          this._deleteRoute(edgeRoute);
-        }
-      }
-      return;
-    }
-  }
-  handleOrbProtocolChanged(orb) {
-    const meta = MEM.ORB_META.get(orb);
-    if (!meta || meta.anchor !== this)
-      return;
-    this._dirty.add(meta.uuid);
-    this._emitObserve({
-      type: "protocol:change",
-      uuid: meta.uuid,
-      shape: MEM.ORB_PLAN.get(orb)?.id,
-      routes: [...meta.routes]
-    });
-    for (const route of meta.routes) {
-      this._deriveOrbRoutes(orb, route);
-    }
-  }
-  at(route) {
-    const { anchor, local } = this._resolveRouteOwner(route);
-    trackDependency(anchor, routeDependency(local));
-    return anchor.get(local);
-  }
-  get(routeOrUuid) {
-    if (typeof routeOrUuid !== "string") {
-      throw new TypeError("Anchor.get() expects a route or UUID ref");
-    }
-    if (routeOrUuid.startsWith("$uuid:")) {
-      return this._uuidToOrb.get(parseUuidRef(routeOrUuid).uuid);
-    }
-    const { anchor, local } = this._resolveRouteOwner(routeOrUuid);
-    const uuid = anchor._routeToUuid.get(local);
-    return uuid ? anchor._uuidToOrb.get(uuid) : undefined;
-  }
-  async load(routeOrUuid) {
-    if (routeOrUuid.startsWith("$uuid:")) {
-      return this._loadUuid(parseUuidRef(routeOrUuid).uuid);
-    }
-    const { anchor, local } = await this._resolveRouteOwnerAsync(routeOrUuid);
-    if (anchor !== this) {
-      return anchor.load(local);
-    }
-    let uuid = this._routeToUuid.get(local);
-    if (!uuid) {
-      uuid = await this.adapter.routes?.get?.(local);
-    }
-    if (!uuid)
-      return;
-    assertUuid(uuid, `Malformed route '${local}'`);
-    const orb = await this._loadUuid(uuid);
-    this._setRoute(local, uuid);
-    this._deriveOrbRoutes(orb, local);
-    return orb;
-  }
-  async save(routeOrUuid) {
-    if (routeOrUuid) {
-      if (!routeOrUuid.startsWith("$uuid:")) {
-        const { anchor, local } = this._resolveRouteOwner(routeOrUuid);
-        if (anchor !== this) {
-          return anchor.save(local);
-        }
-        const uuid = this._routeToUuid.get(local);
-        if (uuid) {
-          this._deletedRoutes.delete(local);
-          await this.adapter.routes?.set?.(local, uuid);
-        }
-      }
-      const orb = this.get(routeOrUuid);
-      if (!orb)
-        return;
-      await this._saveOrb(orb);
-      return;
-    }
-    await this.saveAllDirty();
-  }
-  async saveAllDirty() {
-    for (const [route, uuid] of this._routeToUuid) {
-      this._deletedRoutes.delete(route);
-      await this.adapter.routes?.set?.(route, uuid);
-    }
-    for (const route of this._deletedRoutes) {
-      await this.adapter.routes?.delete?.(route);
-    }
-    this._deletedRoutes.clear();
-    const reachable = this._collectLiveReachableUuids();
-    const dirty = [...this._dirty].filter((uuid) => reachable.has(uuid));
-    this._dirty.clear();
-    for (const uuid of dirty) {
-      const orb = this._uuidToOrb.get(uuid);
-      if (orb) {
-        await this._saveOrb(orb);
-      }
-    }
-  }
-  async collectGarbage() {
-    const listRoutes = this.adapter.routes?.list;
-    const deleteRoute = this.adapter.routes?.delete;
-    const listOrbs = this.adapter.state?.listOrbs;
-    const deleteOrb = this.adapter.state?.deleteOrb;
-    if (typeof listRoutes !== "function") {
-      throw new Error("Anchor GC requires adapter.routes.list()");
-    }
-    if (typeof deleteRoute !== "function") {
-      throw new Error("Anchor GC requires adapter.routes.delete()");
-    }
-    if (typeof listOrbs !== "function") {
-      throw new Error("Anchor GC requires adapter.state.listOrbs()");
-    }
-    if (typeof deleteOrb !== "function") {
-      throw new Error("Anchor GC requires adapter.state.deleteOrb()");
-    }
-    await this.saveAllDirty();
-    const routeRecords = await listRoutes.call(this.adapter.routes);
-    const orbRecords = await listOrbs.call(this.adapter.state);
-    const recordsByUuid = new Map;
-    const routeToUuid = new Map;
-    for (const record of orbRecords ?? []) {
-      if (record?.uuid) {
-        recordsByUuid.set(record.uuid, record);
-      }
-    }
-    for (const record of routeRecords ?? []) {
-      if (!record)
-        continue;
-      const route = record.route;
-      const uuid = record.uuid;
-      assertRoute(route);
-      assertUuid(uuid, `Malformed route '${route}'`);
-      routeToUuid.set(route, uuid);
-    }
-    const retained = new Set;
-    const pending = [...routeToUuid.values()];
-    while (pending.length > 0) {
-      const uuid = pending.pop();
-      if (retained.has(uuid))
-        continue;
-      retained.add(uuid);
-      const record = recordsByUuid.get(uuid);
-      if (!record)
-        continue;
-      assertOrbRecord(record, uuid);
-      for (const ref of collectSerializedRefs(record.state)) {
-        const targetUuid = resolveLocalSerializedRef(ref, routeToUuid, this.id);
-        if (targetUuid && !retained.has(targetUuid)) {
-          pending.push(targetUuid);
-        }
-      }
-    }
-    const deleted = [];
-    for (const uuid of recordsByUuid.keys()) {
-      if (retained.has(uuid))
-        continue;
-      await deleteOrb.call(this.adapter.state, uuid);
-      this._dirty.delete(uuid);
-      deleted.push(uuid);
-    }
-    return { retained: retained.size, deleted };
-  }
-  dispose() {
-    if (this._disposed)
-      return;
-    this._disposed = true;
-    if (this._autosaveTimer) {
-      clearInterval(this._autosaveTimer);
-      this._autosaveTimer = null;
-    }
-    for (const orb of this._uuidToOrb.values()) {
-      disposeMountedOrb(orb);
-    }
-  }
-  fullRef(ref) {
-    if (ref.startsWith("$uuid:") || ref.includes(":"))
-      return ref;
-    return `${this.id}:${ref}`;
-  }
-  _ensureOrb(orb) {
-    if (!MEM.ORB_PLAN.get(orb)) {
-      throw new TypeError("Anchor can only adopt Orb nodes");
-    }
-    const existing = MEM.ORB_META.get(orb);
-    if (existing?.anchor === this) {
-      return existing.uuid;
-    }
-    const uuid = this._createUuid();
-    MEM.ORB_META.set(orb, {
-      anchor: this,
-      uuid,
-      routes: existing?.routes ?? new Set
-    });
-    this._uuidToOrb.set(uuid, orb);
-    this._dirty.add(uuid);
-    bindMountedOrb(this, orb);
-    return uuid;
-  }
-  _adoptValueAtRoute(route, value) {
-    if (value instanceof LazyRef) {
-      const ref = parseLazyUuidRef(value);
-      if (ref && !ref.path) {
-        this._setRoute(route, ref.uuid, { dirty: false });
-        return true;
-      }
-      return false;
-    }
-    if (MEM.ORB_PLAN.get(value)) {
-      const adopted = this._mountValueForAnchor(value);
-      const uuid = this._ensureOrb(adopted);
-      this._setRoute(route, uuid);
-      this._deriveOrbRoutes(adopted, route);
-      return adopted;
-    }
-    return false;
-  }
-  _deriveOrbRoutes(orb, route) {
-    if (!MEM.ORB_PLAN.get(orb))
-      return;
-    const seenRoutes = new Set;
-    for (const edge of getEdges(orb)) {
-      const edgeRoute = joinRoute(route, edge.segment);
-      if (this._adoptValueAtRoute(edgeRoute, edge.peek())) {
-        seenRoutes.add(edgeRoute);
-      }
-    }
-    for (const existingRoute of [...this._routeToUuid.keys()]) {
-      if (isDirectEdgeRoute(route, existingRoute) && !seenRoutes.has(existingRoute)) {
-        this._deleteRoute(existingRoute);
-      }
-    }
-  }
-  _createUuid() {
-    const adapterUuid = this.adapter.state?.createUuid?.();
-    if (adapterUuid) {
-      return adapterUuid;
-    }
-    return `${this.id.replace(/[^a-zA-Z0-9_-]/g, "_")}_${this._nextUuid++}`;
-  }
-  _setRoute(route, uuid, options = {}) {
-    const previousUuid = this._routeToUuid.get(route);
-    const dirty = options.dirty ?? true;
-    this._deletedRoutes.delete(route);
-    this._routeToUuid.set(route, uuid);
-    const orb = this._uuidToOrb.get(uuid);
-    if (orb) {
-      const meta = MEM.ORB_META.get(orb);
-      meta.routes.add(route);
-      bindMountedOrb(this, orb);
-    }
-    if (dirty) {
-      this._dirty.add(uuid);
-    }
-    notifyDependencyChanged(this, routeDependency(route));
-    const event = {
-      type: "route:set",
-      route,
-      uuid
-    };
-    if (previousUuid && previousUuid !== uuid) {
-      event.previousUuid = previousUuid;
-    }
-    if (orb) {
-      event.shape = MEM.ORB_PLAN.get(orb)?.id;
-    }
-    this._emitObserve(event);
-  }
-  _deleteRoute(route) {
-    const uuid = this._routeToUuid.get(route);
-    if (!uuid)
-      return;
-    this._routeToUuid.delete(route);
-    this._deletedRoutes.add(route);
-    const orb = this._uuidToOrb.get(uuid);
-    const meta = orb ? MEM.ORB_META.get(orb) : null;
-    meta?.routes?.delete(route);
-    if (orb)
-      bindMountedOrb(this, orb);
-    notifyDependencyChanged(this, routeDependency(route));
-    this._emitObserve({
-      type: "route:delete",
-      route,
-      uuid
-    });
-  }
-  _emitObserve(event) {
-    if (this._observers.size === 0)
-      return;
-    const frozen = Object.freeze({
-      anchorId: this.id,
-      ...event
-    });
-    for (const observer of [...this._observers]) {
-      observer(frozen);
-    }
-  }
-  async _saveOrb(orb) {
-    const meta = MEM.ORB_META.get(orb);
-    const plan = MEM.ORB_PLAN.get(orb);
-    if (!meta || !plan)
-      return;
-    const sourcePlan = getMountSourcePlan(orb);
-    const record = {
-      uuid: meta.uuid,
-      shape: sourcePlan?.id ?? plan.id,
-      state: sourcePlan ? this._serializeOrbStateForPlan(orb, sourcePlan) : this._serializeOrbState(orb)
-    };
-    await this.adapter.state?.saveOrb?.(record);
-  }
-  _serializeOrbState(orb) {
-    const saved = orb[VOCAB.SHAPE.SAVE]();
-    if (Array.isArray(saved)) {
-      const out2 = [];
-      for (const edge of getEdges(orb)) {
-        out2[Number(edge.key)] = this._serializeValue(edge.peek());
-      }
-      return out2;
-    }
-    if (!saved || typeof saved !== "object") {
-      return saved;
-    }
-    const out = JSON.parse(JSON.stringify(saved));
-    for (const edge of getEdges(orb)) {
-      out[edge.key] = this._serializeValue(edge.peek());
-    }
-    return out;
-  }
-  _serializeValue(value) {
-    if (value instanceof OrbLink) {
-      const { source, key } = value.target();
-      return { $: `$uuid:${this._ensureOrb(source)}/${key}` };
-    }
-    if (value instanceof LazyRef) {
-      return { $: value.ref };
-    }
-    if (MEM.ORB_PLAN.get(value)) {
-      return { $: `$uuid:${this._ensureOrb(value)}` };
-    }
-    if (value === undefined)
-      return;
-    return JSON.parse(JSON.stringify(value));
-  }
-  _serializeOrbStateForPlan(orb, plan) {
-    const out = {};
-    for (const entry of plan.serializable) {
-      const edge = orb[VOCAB.SHAPE.EDGE](entry.key);
-      out[entry.key] = this._serializeValue(edge.peek());
-    }
-    return out;
-  }
-  _collectLiveReachableUuids() {
-    const reachable = new Set;
-    for (const uuid of this._routeToUuid.values()) {
-      this._collectLiveReachableUuid(uuid, reachable);
-    }
-    return reachable;
-  }
-  _collectLiveReachableUuid(uuid, reachable) {
-    if (!uuid || reachable.has(uuid))
-      return;
-    reachable.add(uuid);
-    const orb = this._uuidToOrb.get(uuid);
-    if (!orb)
-      return;
-    for (const edge of getEdges(orb)) {
-      this._collectLiveReachableValue(edge.peek(), reachable);
-    }
-  }
-  _collectLiveReachableValue(value, reachable) {
-    if (value instanceof OrbLink) {
-      const { source } = value.target();
-      this._collectLiveReachableUuid(this._ensureOrb(source), reachable);
-      return;
-    }
-    if (value instanceof LazyRef) {
-      const ref = parseLazyUuidRef(value);
-      if (ref) {
-        this._collectLiveReachableUuid(ref.uuid, reachable);
-      }
-      return;
-    }
-    if (MEM.ORB_PLAN.get(value)) {
-      this._collectLiveReachableUuid(this._ensureOrb(value), reachable);
-    }
-  }
-  async _loadUuid(uuid) {
-    assertUuid(uuid, "Malformed UUID");
-    if (this._uuidToOrb.has(uuid)) {
-      return this._uuidToOrb.get(uuid);
-    }
-    const record = await this.adapter.state?.loadOrb?.(uuid);
-    if (!record)
-      return;
-    assertOrbRecord(record, uuid);
-    let shape = await this.adapter.shapes?.load?.(record.shape);
-    if (!shape) {
-      throw new Error(`Missing Shape '${record.shape}'`);
-    }
-    shape = this.resolveMount(shape) ?? shape;
-    const input = await this._reviveValue(record.state);
-    const orb = shape.hydrate(input);
-    MEM.ORB_META.set(orb, {
-      anchor: this,
-      uuid,
-      routes: new Set
-    });
-    this._uuidToOrb.set(uuid, orb);
-    this._registerLazyInputTargets(orb, input);
-    this._registerLazyEdges(orb);
-    this._resolvePendingLazy(uuid, orb);
-    this._deriveOrbRoutesFromKnownRoutes(orb);
-    return orb;
-  }
-  _mountValueForAnchor(value) {
-    if (isMountedOrb(value))
-      return value;
-    const plan = MEM.ORB_PLAN.get(value);
-    const factory = plan?.factory;
-    if (!factory)
-      return value;
-    const mountedFactory = this.resolveMount(factory);
-    if (!mountedFactory)
-      return value;
-    return mountedFactory.hydrate(this._serializeOrbStateForPlan(value, plan));
-  }
-  async _reviveValue(value) {
-    if (isSerializedRef(value)) {
-      const ref = value.$;
-      if (ref.startsWith("$uuid:")) {
-        const { uuid, path } = parseUuidRef(ref);
-        if (this.loading === "lazy" && !path) {
-          return new LazyRef(ref);
-        }
-        const target = await this._loadUuid(uuid);
-        return path ? target.$(path) : target;
-      }
-      return this.load(ref);
-    }
-    if (Array.isArray(value)) {
-      const out = [];
-      for (const item of value) {
-        out.push(await this._reviveValue(item));
-      }
-      return out;
-    }
-    if (value && typeof value === "object") {
-      const out = {};
-      for (const [key, nested] of Object.entries(value)) {
-        out[key] = await this._reviveValue(nested);
-      }
-      return out;
-    }
-    return value;
-  }
-  _deriveOrbRoutesFromKnownRoutes(orb) {
-    const meta = MEM.ORB_META.get(orb);
-    if (!meta)
-      return;
-    for (const [route, uuid] of this._routeToUuid) {
-      if (uuid === meta.uuid) {
-        meta.routes.add(route);
-        this._deriveOrbRoutes(orb, route);
-      }
-    }
-  }
-  _registerLazyEdges(orb) {
-    for (const edge of getEdges(orb)) {
-      this._registerLazyTarget(orb, edge.key, edge.peek());
-    }
-  }
-  _registerLazyInputTargets(orb, input) {
-    if (!input || typeof input !== "object")
-      return;
-    if (Array.isArray(input)) {
-      input.forEach((value, index) => {
-        this._registerLazyTarget(orb, String(index), value);
-      });
-      return;
-    }
-    for (const [key, value] of Object.entries(input)) {
-      this._registerLazyTarget(orb, key, value);
-    }
-  }
-  _registerLazyTarget(target, key, value) {
-    const ref = parseLazyUuidRef(value);
-    if (!ref || ref.path)
-      return;
-    let pending = this._pendingLazyByUuid.get(ref.uuid);
-    if (!pending) {
-      pending = new Set;
-      this._pendingLazyByUuid.set(ref.uuid, pending);
-    }
-    for (const entry of pending) {
-      if (entry.target === target && entry.key === key) {
-        return;
-      }
-    }
-    pending.add({ target, key });
-  }
-  _resolvePendingLazy(uuid, value) {
-    const pending = this._pendingLazyByUuid.get(uuid);
-    if (!pending)
-      return;
-    this._pendingLazyByUuid.delete(uuid);
-    for (const { target, key } of pending) {
-      resolveLazyRef(target, key, value);
-    }
-  }
-  _resolveRouteOwner(ref) {
-    const parsed = parseRouteRef(ref);
-    if (!parsed.anchorId || parsed.anchorId === this.id) {
-      return { anchor: this, local: parsed.route };
-    }
-    const connected = this._findConnectedAnchor(parsed.anchorId);
-    if (!connected) {
-      const resolved = this._resolveConfiguredAnchor(parsed.anchorId);
-      if (isPromiseLike(resolved)) {
-        throw new Error(`Async Anchor resolver for '${parsed.anchorId}' requires load()`);
-      }
-      if (resolved) {
-        return { anchor: resolved, local: parsed.route };
-      }
-      throw new Error(`Unresolved Anchor '${parsed.anchorId}'`);
-    }
-    return { anchor: connected, local: parsed.route };
-  }
-  async _resolveRouteOwnerAsync(ref) {
-    const parsed = parseRouteRef(ref);
-    if (!parsed.anchorId || parsed.anchorId === this.id) {
-      return { anchor: this, local: parsed.route };
-    }
-    const connected = this._findConnectedAnchor(parsed.anchorId);
-    if (connected) {
-      return { anchor: connected, local: parsed.route };
-    }
-    const resolved = await this._resolveConfiguredAnchor(parsed.anchorId);
-    if (!resolved) {
-      throw new Error(`Unresolved Anchor '${parsed.anchorId}'`);
-    }
-    assertResolvedAnchor(parsed.anchorId, resolved);
-    return { anchor: resolved, local: parsed.route };
-  }
-  _resolveConfiguredAnchor(anchorId) {
-    if (!this._resolveAnchor)
-      return null;
-    const anchor = this._resolveAnchor(anchorId);
-    if (!anchor || isPromiseLike(anchor))
-      return anchor;
-    assertResolvedAnchor(anchorId, anchor);
-    return anchor;
-  }
-  _findConnectedAnchor(anchorId, seen = new Set) {
-    if (this.id === anchorId)
-      return this;
-    if (seen.has(this))
-      return null;
-    seen.add(this);
-    for (const anchor of this._connections.values()) {
-      const found = anchor._findConnectedAnchor(anchorId, seen);
-      if (found)
-        return found;
-    }
-    return null;
-  }
-  _collectAnchorIds(seen = new Set, ids = new Set) {
-    if (seen.has(this))
-      return ids;
-    seen.add(this);
-    ids.add(this.id);
-    for (const anchor of this._connections.values()) {
-      anchor._collectAnchorIds(seen, ids);
-    }
-    return ids;
-  }
-  _startAutosave(options) {
-    const intervalMs = options?.intervalMs;
-    if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
-      throw new Error("Anchor autosave intervalMs must be a positive number");
-    }
-    this._autosaveTimer = setInterval(() => {
-      this._runAutosave();
-    }, intervalMs);
-    this._autosaveTimer.unref?.();
-  }
-  async _runAutosave() {
-    if (this._disposed || this._autosaveRunning)
-      return;
-    this._autosaveRunning = true;
-    try {
-      await this.saveAllDirty();
-    } finally {
-      this._autosaveRunning = false;
-    }
-  }
-}
-MEM.BASE_ANCHOR = new Anchor({ id: "default" });
-var baseAnchor = MEM.BASE_ANCHOR;
-function parseUuidRef(ref) {
-  const body = ref.slice("$uuid:".length);
-  if (!body) {
-    throw new Error(`Malformed ref '${ref}'`);
-  }
-  const slash = body.indexOf("/");
-  if (slash === -1) {
-    return { uuid: body, path: "" };
-  }
-  const uuid = body.slice(0, slash);
-  const path = body.slice(slash + 1);
-  if (!uuid || !path) {
-    throw new Error(`Malformed ref '${ref}'`);
-  }
-  return {
-    uuid,
-    path
-  };
-}
-function parseLazyUuidRef(value) {
-  if (!(value instanceof LazyRef))
-    return null;
-  if (!value.ref.startsWith("$uuid:"))
-    return null;
-  return parseUuidRef(value.ref);
-}
-function parseRouteRef(ref) {
-  if (typeof ref !== "string") {
-    throw new TypeError("Anchor route ref must be a string");
-  }
-  const colon = ref.indexOf(":");
-  if (colon === -1) {
-    assertRoute(ref);
-    return { anchorId: undefined, route: ref };
-  }
-  const anchorId = ref.slice(0, colon);
-  const route = ref.slice(colon + 1);
-  if (!anchorId) {
-    throw new Error(`Malformed route ref '${ref}'`);
-  }
-  assertRoute(route);
-  return { anchorId, route };
-}
-function routeDependency(route) {
-  return `route:${route}`;
-}
-function joinRoute(parent, segment) {
-  assertRouteSegment(segment);
-  return `${parent}/${segment}`;
-}
-function getEdges(value) {
-  return value[VOCAB.SHAPE.KEYS]().map((key) => value[VOCAB.SHAPE.EDGE](key));
-}
-function getEdge(value, key) {
-  try {
-    return value[VOCAB.SHAPE.EDGE](key);
-  } catch {
-    return;
-  }
-}
-function isDirectEdgeRoute(parent, route) {
-  if (!route.startsWith(`${parent}/`))
-    return false;
-  return !route.slice(parent.length + 1).includes("/");
-}
-function assertRoute(route) {
-  if (typeof route !== "string" || route.length === 0 || route.startsWith("$uuid:")) {
-    throw new Error("Anchor route must be a non-empty route string");
-  }
-  for (const segment of route.split("/")) {
-    assertRouteSegment(segment);
-  }
-}
-function assertUuid(uuid, message) {
-  if (typeof uuid !== "string" || uuid.length === 0) {
-    throw new Error(message);
-  }
-}
-function assertOrbRecord(record, expectedUuid) {
-  const valid = record && typeof record === "object" && !Array.isArray(record) && typeof record.uuid === "string" && record.uuid === expectedUuid && typeof record.shape === "string" && record.shape.length > 0 && Object.prototype.hasOwnProperty.call(record, "state");
-  if (!valid) {
-    throw new Error(`Malformed Orb record '${expectedUuid}'`);
-  }
-}
-function assertAnchor(anchor) {
-  if (!anchor || typeof anchor.id !== "string" || typeof anchor.get !== "function") {
-    throw new TypeError("Expected an Anchor");
-  }
-}
-function assertResolvedAnchor(anchorId, anchor) {
-  assertAnchor(anchor);
-  if (anchor.id !== anchorId) {
-    throw new Error(`Anchor resolver returned '${anchor.id}' for '${anchorId}'`);
-  }
-}
-function hasSharedAnchorId(left, right) {
-  const leftIds = left._collectAnchorIds();
-  const rightIds = right._collectAnchorIds();
-  for (const id of rightIds) {
-    if (leftIds.has(id))
-      return true;
-  }
-  return false;
-}
-function isPromiseLike(value) {
-  return Boolean(value && typeof value.then === "function");
-}
-function normalizeMountTargets(value) {
-  if (value === undefined)
-    return [];
-  const list = Array.isArray(value) ? value : [value];
-  const seen = new Set;
-  const out = [];
-  for (const target of list) {
-    if (typeof target !== "string" || target.length === 0) {
-      throw new TypeError("Anchor mount targets must be non-empty strings");
-    }
-    assertRouteSegment(target);
-    if (seen.has(target))
-      continue;
-    seen.add(target);
-    out.push(target);
-  }
-  return out;
-}
-function isSerializedRef(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value) && typeof value.$ === "string" && Object.keys(value).length === 1);
-}
-function collectSerializedRefs(value, refs = []) {
-  if (isSerializedRef(value)) {
-    refs.push(value.$);
-    return refs;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      collectSerializedRefs(item, refs);
-    }
-    return refs;
-  }
-  if (value && typeof value === "object") {
-    for (const nested of Object.values(value)) {
-      collectSerializedRefs(nested, refs);
-    }
-  }
-  return refs;
-}
-function resolveLocalSerializedRef(ref, routeToUuid, anchorId) {
-  if (ref.startsWith("$uuid:")) {
-    return parseUuidRef(ref).uuid;
-  }
-  const parsed = parseRouteRef(ref);
-  if (parsed.anchorId && parsed.anchorId !== anchorId) {
-    return;
-  }
-  return routeToUuid.get(parsed.route);
-}
-function createMemoryAdapter() {
-  const records = new Map;
-  const routes = new Map;
-  let nextUuid = 1;
-  return {
-    state: {
-      createUuid() {
-        return `u${nextUuid++}`;
-      },
-      async loadOrb(uuid) {
-        return records.get(uuid) ?? null;
-      },
-      async saveOrb(record) {
-        records.set(record.uuid, JSON.parse(JSON.stringify(record)));
-      },
-      async deleteOrb(uuid) {
-        records.delete(uuid);
-      },
-      async listOrbs() {
-        return [...records.values()].map((record) => JSON.parse(JSON.stringify(record)));
-      }
-    },
-    routes: {
-      async get(route) {
-        return routes.get(route) ?? null;
-      },
-      async set(route, uuid) {
-        routes.set(route, uuid);
-      },
-      async delete(route) {
-        routes.delete(route);
-      },
-      async list() {
-        return [...routes].map(([route, uuid]) => ({ route, uuid }));
-      }
-    },
-    shapes: {
-      async load() {
-        return null;
-      },
-      async register() {}
-    }
-  };
-}
-// ../orbz/src/libShapes/Dict.js
-var DICT_KEYS = "dict:keys";
-var dictValueToken = (key) => `dict:value:${key}`;
-var dictPresenceToken = (key) => `dict:presence:${key}`;
-var Dict = Shape({
-  [Shape.name]: "Dict",
-  _values: {},
-  get get() {
-    return (key) => this[Shape.edge](key).peek();
-  },
-  get at() {
-    return (key) => this[Shape.edge](key).read();
-  },
-  set(key, value) {
-    return this[Shape.edge](key).write(value);
-  },
-  delete(key) {
-    return this[Shape.edge](key).delete();
-  },
-  get has() {
-    return (key) => {
-      const normalized = normalizeKey(key);
-      this.$.track(dictPresenceToken(normalized));
-      return Object.prototype.hasOwnProperty.call(this._values, normalized);
-    };
-  },
-  get keys() {
-    return () => this[Shape.keys]();
-  },
-  get all() {
-    return () => {
-      const out = {};
-      for (const key of this[Shape.keys]())
-        out[key] = this[Shape.edge](key).read();
-      return out;
-    };
-  },
-  get each() {
-    return (callback) => {
-      if (typeof callback !== "function") {
-        throw new TypeError("Dict.each() expects a callback");
-      }
-      for (const key of this[Shape.keys]())
-        callback(this[Shape.edge](key).read(), key, this);
-    };
-  },
-  eachEffect(callback, options = {}) {
-    return createEachEffect({
-      node: this,
-      callback,
-      options,
-      keys: () => this[Shape.keys](),
-      peek: (key) => this[Shape.edge](key).peek(),
-      read: (key) => this[Shape.edge](key).read()
-    });
-  },
-  [Shape.init](initial = {}) {
-    if (!initial || typeof initial !== "object" || Array.isArray(initial)) {
-      throw new TypeError("Dict() expects an object");
-    }
-    const values = {};
-    for (const [key, value] of Object.entries(initial))
-      values[normalizeKey(key)] = value;
-    return { _values: values };
-  },
-  [Shape.load](initial = {}) {
-    return this[Shape.init](initial);
-  },
-  [Shape.save]() {
-    const out = {};
-    for (const key of Object.keys(this._values))
-      out[key] = serializeSlot(this._values[key]);
-    return out;
-  },
-  [Shape.keys]() {
-    this.$.track(DICT_KEYS);
-    return Object.keys(this._values);
-  },
-  [Shape.edge](key) {
-    const normalized = normalizeKey(key);
-    const node = this;
-    const values = this._values;
-    return {
-      key: normalized,
-      segment: normalized,
-      read() {
-        node.$.track(dictValueToken(normalized));
-        return readSlot(values[normalized]);
-      },
-      peek() {
-        return values[normalized];
-      },
-      write(value) {
-        setDictValue(node, values, normalized, value);
-        return value;
-      },
-      delete() {
-        return deleteDictValue(node, values, normalized);
-      },
-      save() {
-        return serializeSlot(values[normalized]);
-      }
-    };
-  }
-});
-function setDictValue(node, values, key, value) {
-  const hadKey = Object.prototype.hasOwnProperty.call(values, key);
-  const previous = values[key];
-  if (Object.is(previous, value) && hadKey)
-    return;
-  batch(() => {
-    values[key] = value;
-    node.$.changed(dictValueToken(key));
-    if (!hadKey) {
-      node.$.changed(DICT_KEYS);
-      node.$.changed(dictPresenceToken(key));
-    }
-  });
-}
-function deleteDictValue(node, values, key) {
-  if (!Object.prototype.hasOwnProperty.call(values, key))
-    return false;
-  batch(() => {
-    delete values[key];
-    node.$.changed(DICT_KEYS);
-    node.$.changed(dictPresenceToken(key));
-    node.$.changed(dictValueToken(key));
-  });
-  return true;
-}
-function normalizeKey(key) {
-  if (typeof key !== "string") {
-    throw new TypeError("Dict keys must be strings");
-  }
-  assertRouteSegment(key);
-  return key;
-}
-// ../orbz/src/libShapes/List.js
-var LIST_ITEMS = "list:items";
-var LIST_LENGTH = "list:length";
-var listItemToken = (index) => `list:item:${index}`;
-var List = Shape({
-  [Shape.name]: "List",
-  _values: [],
-  get length() {
-    this.$.track(LIST_LENGTH);
-    return this._values.length;
-  },
-  get keys() {
-    return () => this[Shape.keys]();
-  },
-  get get() {
-    return (index) => this[Shape.edge](index).peek();
-  },
-  get at() {
-    return (index) => this[Shape.edge](index).read();
-  },
-  set(index, value) {
-    return this[Shape.edge](index).write(value);
-  },
-  push(value) {
-    return pushListValue(this, this._values, value);
-  },
-  removeAt(index) {
-    return this[Shape.edge](index).delete();
-  },
-  get toArray() {
-    return () => {
-      this.$.track(LIST_ITEMS);
-      return [...this._values];
-    };
-  },
-  get all() {
-    return () => this.toArray();
-  },
-  get each() {
-    return (callback) => {
-      if (typeof callback !== "function") {
-        throw new TypeError("List.each() expects a callback");
-      }
-      for (const index of this[Shape.keys]())
-        callback(this[Shape.edge](index).read(), index, this);
-    };
-  },
-  eachEffect(callback, options = {}) {
-    return createEachEffect({
-      node: this,
-      callback,
-      options,
-      keys: () => this[Shape.keys](),
-      peek: (index) => this[Shape.edge](index).peek(),
-      read: (index) => this[Shape.edge](index).read()
-    });
-  },
-  get map() {
-    return (callback) => new DerivedListView(this, callback);
-  },
-  [Shape.init](initial = []) {
-    if (!Array.isArray(initial)) {
-      throw new TypeError("List() expects an array");
-    }
-    return { _values: [...initial] };
-  },
-  [Shape.load](initial = []) {
-    return this[Shape.init](initial);
-  },
-  [Shape.save]() {
-    return this._values.map(serializeSlot);
-  },
-  [Shape.keys]() {
-    this.$.track(LIST_LENGTH);
-    return this._values.map((_, index) => index);
-  },
-  [Shape.edge](index) {
-    const normalized = normalizeIndex(index);
-    const node = this;
-    const values = this._values;
-    return {
-      key: normalized,
-      segment: String(normalized),
-      read() {
-        node.$.track(listItemToken(normalized));
-        return readSlot(values[normalized]);
-      },
-      peek() {
-        return values[normalized];
-      },
-      write(value) {
-        setListValue(node, values, normalized, value);
-        return value;
-      },
-      delete() {
-        return removeListValue(node, values, normalized);
-      },
-      save() {
-        return serializeSlot(values[normalized]);
-      }
-    };
-  }
-});
-
-class DerivedListView {
-  constructor(source, mapper) {
-    if (typeof mapper !== "function") {
-      throw new TypeError("List.map() expects a callback");
-    }
-    this._source = source;
-    this._mapper = mapper;
-  }
-  get length() {
-    return this._source.length;
-  }
-  keys() {
-    return this._source.keys();
-  }
-  get(index) {
-    const normalized = normalizeIndex(index);
-    return this._mapper(this._source.get(normalized), normalized, this._source);
-  }
-  at(index) {
-    const normalized = normalizeIndex(index);
-    return this._mapper(this._source.at(normalized), normalized, this._source);
-  }
-  toArray() {
-    return this.keys().map((index) => this.at(index));
-  }
-  all() {
-    return this.toArray();
-  }
-  each(callback) {
-    if (typeof callback !== "function") {
-      throw new TypeError("List.each() expects a callback");
-    }
-    for (const index of this.keys())
-      callback(this.at(index), index, this);
-  }
-  eachEffect(callback, options = {}) {
-    return createEachEffect({
-      node: this,
-      callback,
-      options,
-      keys: () => this.keys(),
-      peek: (index) => this.get(index),
-      read: (index) => this.at(index)
-    });
-  }
-  map(callback) {
-    return new DerivedListView(this, callback);
-  }
-  toJSON() {
-    return this.toArray();
-  }
-}
-function setListValue(node, values, index, value) {
-  const previousLength = values.length;
-  const previous = values[index];
-  if (Object.is(previous, value) && index in values)
-    return;
-  batch(() => {
-    values[index] = value;
-    if (values.length !== previousLength)
-      node.$.changed(LIST_LENGTH);
-    node.$.changed(listItemToken(index));
-    node.$.changed(LIST_ITEMS);
-  });
-}
-function pushListValue(node, values, value) {
-  batch(() => {
-    const index = values.length;
-    values.push(value);
-    node.$.changed(LIST_LENGTH);
-    node.$.changed(listItemToken(index));
-    node.$.changed(LIST_ITEMS);
-  });
-  return values.length;
-}
-function removeListValue(node, values, index) {
-  if (index < 0 || index >= values.length)
-    return;
-  let removed;
-  batch(() => {
-    removed = values.splice(index, 1)[0];
-    node.$.changed(LIST_LENGTH);
-    for (let i = index;i <= values.length; i += 1)
-      node.$.changed(listItemToken(i));
-    node.$.changed(LIST_ITEMS);
-  });
-  return removed;
-}
-function normalizeIndex(index) {
-  if (!Number.isInteger(index) || index < 0) {
-    throw new TypeError("List indexes must be non-negative integers");
-  }
-  return index;
-}
 // src/core.js
+import { Anchor, batch, describe } from "orbz";
 function createProtocolCodec() {
   return {
     encode(message) {