@neocompose/cli 0.73.2 → 0.75.0

package/dist/test-worker.mjs

@@ -1124,16 +1124,16 @@ function memberKindSupportsDistribution(kind) {
   return memberKindSupportsStorage(kind);
 }
 
-// node_modules/uuid/dist-node/regex.js
+// ../node_modules/uuid/dist-node/regex.js
 var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
 
-// node_modules/uuid/dist-node/validate.js
+// ../node_modules/uuid/dist-node/validate.js
 function validate(uuid) {
   return typeof uuid === "string" && regex_default.test(uuid);
 }
 var validate_default = validate;
 
-// node_modules/uuid/dist-node/parse.js
+// ../node_modules/uuid/dist-node/parse.js
 function parse(uuid) {
   if (!validate_default(uuid)) {
     throw TypeError("Invalid UUID");
@@ -1143,7 +1143,7 @@ function parse(uuid) {
 }
 var parse_default = parse;
 
-// node_modules/uuid/dist-node/stringify.js
+// ../node_modules/uuid/dist-node/stringify.js
 var byteToHex = [];
 for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -1152,13 +1152,13 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-// node_modules/uuid/dist-node/rng.js
+// ../node_modules/uuid/dist-node/rng.js
 var rnds8 = new Uint8Array(16);
 function rng() {
   return crypto.getRandomValues(rnds8);
 }
 
-// node_modules/uuid/dist-node/v35.js
+// ../node_modules/uuid/dist-node/v35.js
 function stringToBytes(str) {
   str = unescape(encodeURIComponent(str));
   const bytes = new Uint8Array(str.length);
@@ -1197,7 +1197,7 @@ function v35(version, hash, value, namespace, buf, offset) {
   return unsafeStringify(bytes);
 }
 
-// node_modules/uuid/dist-node/v4.js
+// ../node_modules/uuid/dist-node/v4.js
 function v4(options, buf, offset) {
   if (!buf && !options && crypto.randomUUID) {
     return crypto.randomUUID();
@@ -1226,7 +1226,7 @@ function _v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// node_modules/uuid/dist-node/sha1.js
+// ../node_modules/uuid/dist-node/sha1.js
 import { createHash } from "node:crypto";
 function sha1(bytes) {
   if (Array.isArray(bytes)) {
@@ -1238,7 +1238,7 @@ function sha1(bytes) {
 }
 var sha1_default = sha1;
 
-// node_modules/uuid/dist-node/v5.js
+// ../node_modules/uuid/dist-node/v5.js
 function v5(value, namespace, buf, offset) {
   return v35(80, sha1_default, value, namespace, buf, offset);
 }
@@ -3629,24 +3629,30 @@ function isNSInstructionTry(value) {
   }
   return true;
 }
-function isNSInstructionChangeListener(value) {
-  const instruction = value;
-  if (instruction?.type !== "addChangeListener" /* addChangeListener */ && instruction?.type !== "removeChangeListener" /* removeChangeListener */)
-    return false;
-  const target = instruction.target;
+function isNSChangeListenerTarget(value) {
+  const target = value;
   if (!target || typeof target.memberId !== "string" || target.memberId.length === 0)
     return false;
   if (!isNSPointer(target.owner) || !isNSTypeInfo(target.typeInfo))
     return false;
-  if (!Object.values(NSWritability).includes(target.writability)) return false;
-  return isNSPointer(instruction.listener);
+  return target.writability !== void 0 && Object.values(NSWritability).includes(target.writability);
+}
+function isNSInstructionChangeListener(value) {
+  const instruction = value;
+  if (instruction?.type !== "addChangeListener" /* addChangeListener */ && instruction?.type !== "removeChangeListener" /* removeChangeListener */)
+    return false;
+  return isNSChangeListenerTarget(instruction.target) && isNSPointer(instruction.listener);
+}
+function isNSInstructionClearChangeListeners(value) {
+  const instruction = value;
+  return instruction?.type === "clearChangeListeners" /* clearChangeListeners */ && isNSChangeListenerTarget(instruction.target);
 }
 function isNSInstructionDebug(value) {
   const v = value;
   return v?.type === "debug" /* debug */ && ["log", "warning", "error", "assert"].includes(v.severity ?? "") && isNSPointer(v.message) && isNSTypeInfo(v.messageType) && (v.severity === "assert" ? isNSPointer(v.condition) : v.condition === void 0);
 }
 function isNSInstruction(value) {
-  return isNSInstructionDebug(value) || isNSInstructionVariable(value) || isNSInstructionIfBranch(value) || isNSInstructionReturn(value) || isNSInstructionThrow(value) || isNSInstructionAssign(value) || isNSInstructionCollectionCall(value) || isNSInstructionFunctionCall(value) || isNSInstructionConditionLoop(value) || isNSInstructionFor(value) || isNSInstructionForEach(value) || isNSInstructionBreak(value) || isNSInstructionContinue(value) || isNSInstructionSwitch(value) || isNSInstructionTry(value) || isNSInstructionChangeListener(value) || isNSInstructionAddActionListener(value) || isNSInstructionRemoveActionListener(value);
+  return isNSInstructionDebug(value) || isNSInstructionVariable(value) || isNSInstructionIfBranch(value) || isNSInstructionReturn(value) || isNSInstructionThrow(value) || isNSInstructionAssign(value) || isNSInstructionCollectionCall(value) || isNSInstructionFunctionCall(value) || isNSInstructionConditionLoop(value) || isNSInstructionFor(value) || isNSInstructionForEach(value) || isNSInstructionBreak(value) || isNSInstructionContinue(value) || isNSInstructionSwitch(value) || isNSInstructionTry(value) || isNSInstructionChangeListener(value) || isNSInstructionClearChangeListeners(value) || isNSInstructionAddActionListener(value) || isNSInstructionRemoveActionListener(value);
 }
 function isNSInstructions(value) {
   return Array.isArray(value) && value.every(isNSInstruction);
@@ -13204,6 +13210,9 @@ function listenerWritesByOwner(state) {
   }
   return index.owners;
 }
+function changeListenerWriteEdit(write) {
+  return write.operation === "clear" ? { kind: "replace", targets: [] } : { kind: write.operation, target: write.listener };
+}
 
 // ../src/runtime/neoscript/typed-aggregate-row-references.ts
 function visitTypedAggregateRowReferences(value, rawType, visitor) {
@@ -14859,6 +14868,144 @@ function checkedCoordinate(value) {
   return value;
 }
 
+// ../src/runtime/neoscript/getter-subscriptions.ts
+var NeoScriptGetterSubscription = class {
+  constructor(rowId, getterId, classId) {
+    this.rowId = rowId;
+    this.getterId = getterId;
+    this.classId = classId;
+  }
+  rowId;
+  getterId;
+  classId;
+  targets = [];
+  reads = new InitializerReadSet();
+  queued = false;
+  /** Queued only to arm: its first read calls no handler. */
+  arming = true;
+  /** Its handlers are running. */
+  handling = false;
+};
+var NO_SUBSCRIPTIONS = [];
+var staticReadKey = (memberId) => `static:${memberId}`;
+function* readKeys(reads) {
+  yield* reads.valueIds;
+  yield* reads.containerIds;
+  yield* reads.containerEntryReadIds;
+  for (const id of reads.staticMemberIds) yield staticReadKey(id);
+}
+var NeoScriptGetterSubscriptions = class _NeoScriptGetterSubscriptions {
+  byRow = /* @__PURE__ */ new Map();
+  byRead = /* @__PURE__ */ new Map();
+  /** Reads no row id names, such as corpus or world queries, hear every write. */
+  readingEverything = /* @__PURE__ */ new Set();
+  pending = [];
+  get empty() {
+    return this.byRow.size === 0;
+  }
+  get(rowId, getterId) {
+    return this.byRow.get(rowId)?.get(getterId);
+  }
+  add(subscription) {
+    this.register(subscription);
+    this.queue(subscription);
+  }
+  drop(subscription) {
+    const getters = this.byRow.get(subscription.rowId);
+    if (getters?.get(subscription.getterId) !== subscription) return;
+    getters.delete(subscription.getterId);
+    if (getters.size === 0) this.byRow.delete(subscription.rowId);
+    this.unindex(subscription);
+  }
+  noteValueWrite(rowId) {
+    this.noteRead(rowId);
+  }
+  noteStaticBinding(memberId) {
+    this.noteRead(staticReadKey(memberId));
+  }
+  /** Replace what the subscription's last read touched. */
+  setReads(subscription, reads) {
+    this.unindex(subscription);
+    subscription.reads = reads;
+    if (this.get(subscription.rowId, subscription.getterId) !== subscription)
+      return;
+    if (reads.corpusReadReasons.size > 0 || reads.worldQueries.size > 0)
+      this.readingEverything.add(subscription);
+    for (const key of readKeys(reads)) {
+      let subscriptions = this.byRead.get(key);
+      if (subscriptions === void 0) {
+        subscriptions = /* @__PURE__ */ new Set();
+        this.byRead.set(key, subscriptions);
+      }
+      subscriptions.add(subscription);
+    }
+  }
+  takePending() {
+    if (this.pending.length === 0) return NO_SUBSCRIPTIONS;
+    const pending = this.pending;
+    this.pending = [];
+    return pending;
+  }
+  /** A throw skipped `drained` from `next` on. They stay queued, so none goes deaf. */
+  requeue(drained, next) {
+    for (let index = next; index < drained.length; index += 1)
+      this.pending.push(drained[index]);
+  }
+  /** A copy for a fresh runtime over the same rows, armed exactly as these are. */
+  clone() {
+    const cloned = new _NeoScriptGetterSubscriptions();
+    const copies = /* @__PURE__ */ new Map();
+    for (const getters of this.byRow.values()) {
+      for (const source of getters.values()) {
+        const copy = new NeoScriptGetterSubscription(
+          source.rowId,
+          source.getterId,
+          source.classId
+        );
+        copy.targets.push(...source.targets);
+        copy.arming = source.arming;
+        copies.set(source, copy);
+        cloned.register(copy);
+        cloned.setReads(copy, source.reads);
+      }
+    }
+    for (const source of this.pending) {
+      const copy = copies.get(source);
+      if (copy !== void 0) cloned.queue(copy);
+    }
+    return cloned;
+  }
+  register(subscription) {
+    let getters = this.byRow.get(subscription.rowId);
+    if (getters === void 0) {
+      getters = /* @__PURE__ */ new Map();
+      this.byRow.set(subscription.rowId, getters);
+    }
+    getters.set(subscription.getterId, subscription);
+  }
+  queue(subscription) {
+    if (subscription.queued) return;
+    subscription.queued = true;
+    this.pending.push(subscription);
+  }
+  noteRead(key) {
+    const subscriptions = this.byRead.get(key);
+    if (subscriptions !== void 0)
+      for (const subscription of subscriptions) this.queue(subscription);
+    for (const subscription of this.readingEverything)
+      if (!subscription.handling) this.queue(subscription);
+  }
+  unindex(subscription) {
+    this.readingEverything.delete(subscription);
+    for (const key of readKeys(subscription.reads)) {
+      const subscriptions = this.byRead.get(key);
+      if (subscriptions === void 0) continue;
+      subscriptions.delete(subscription);
+      if (subscriptions.size === 0) this.byRead.delete(key);
+    }
+  }
+};
+
 // ../src/models/decimal/decimal-math.ts
 var DecimalOverflowError = class extends Error {
 };
@@ -15446,6 +15593,7 @@ function evalMemberById(vm, id) {
   return vm.members.find((a) => a.id === id) ?? null;
 }
 function evalValueById(ctx, id, runtimeValues, overlayValues) {
+  ctx.__getterReads?.add(id);
   if (ctx.__removedValueIds?.has(id)) {
     ctx.valueDependencies?.add(id);
     return null;
@@ -16120,8 +16268,13 @@ function bindThisValue(ctx, thisValue) {
   const rowId = thisValue === ctx.thisValue ? ctx.thisValueRowId : trackedRowForValueReference(thisValue, ctx)?.id;
   return { ...ctx, thisValue, thisValueRowId: rowId };
 }
+function observeValueWrite(ctx, row) {
+  ctx.beforeValueWrite?.(row);
+  ctx.__getterSubscriptions?.noteValueWrite(row.id);
+}
 function assertStoredReplayMutableValue(value, ctx, label, key) {
-  if (ctx.storedConstructionReplay !== true && !ctx.assertValueWritable && !ctx.beforeValueWrite)
+  const observesWrites = ctx.beforeValueWrite !== void 0 || ctx.__getterSubscriptions?.empty === false;
+  if (ctx.storedConstructionReplay !== true && !ctx.assertValueWritable && !observesWrites)
     return;
   let rowId = findKnownRowIdByValueReference(value, ctx);
   if (rowId === null) return;
@@ -16140,7 +16293,7 @@ function assertStoredReplayMutableValue(value, ctx, label, key) {
   );
   if (ctx.__runtimeSessionValues?.has(rowId) !== true)
     ctx.assertValueWritable?.(rowId);
-  if (row) ctx.beforeValueWrite?.(row);
+  if (row) observeValueWrite(ctx, row);
   if (ctx.__runtimeSessionValues?.has(rowId) === true) return;
   if (ctx.storedConstructionReplay !== true) return;
   throw new NSGetterRuntimeError(
@@ -16649,10 +16802,14 @@ function readNeoScriptRuntimeRow(ctx, valueId) {
     ctx.__valueOverlay
   );
 }
+function getterSubscriptionsFor(ctx) {
+  return ctx.getterDispatch === "afterEntryStatement" /* AfterEntryStatement */ ? new NeoScriptGetterSubscriptions() : void 0;
+}
 function withEvaluationRuntime(ctx, writes) {
   if (ctx.__runtimeSessionValues !== void 0 && ctx.__executionState !== void 0 && ctx.__valueOverlay !== void 0) {
     ctx.__unorderedListProjections ??= createUnorderedListProjectionCache();
     ctx.__runtimeClassOverrides ??= /* @__PURE__ */ new Map();
+    ctx.__getterSubscriptions ??= getterSubscriptionsFor(ctx);
     return ctx;
   }
   const overlay = ctx.__valueOverlay ?? (ctx.storedConstructionReplay === true ? /* @__PURE__ */ new Map() : buildValueOverlay(ctx.vm));
@@ -16677,6 +16834,7 @@ function withEvaluationRuntime(ctx, writes) {
       trigger: remap(ctx.dialogueContext.trigger)
     },
     __runtimeSessionValues: runtimeSessionValues,
+    __getterSubscriptions: ctx.__getterSubscriptions ?? getterSubscriptionsFor(ctx),
     __copiedChangeListeners: ctx.__copiedChangeListeners ?? /* @__PURE__ */ new Map(),
     __runtimeClassOverrides: ctx.__runtimeClassOverrides ?? /* @__PURE__ */ new Map(),
     __saveStaticBindings: ctx.__saveStaticBindings ?? staticBindingMap(ctx.saveStaticBindings),
@@ -16883,33 +17041,41 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
   const listenerEdges = /* @__PURE__ */ new Map();
   for (const write of state.writes) {
     if (!retainListenerReceivers || write.kind !== "changeListener") continue;
+    const slotKey = JSON.stringify([write.ownerId, write.memberId]);
+    if (write.operation === "clear") {
+      listenerEdges.delete(slotKey);
+      continue;
+    }
     const key = JSON.stringify([
-      write.ownerId,
-      write.memberId,
       write.listener.memberId,
       write.listener.valueId
     ]);
-    if (write.operation === "remove") listenerEdges.delete(key);
-    else listenerEdges.set(key, write);
+    let edges = listenerEdges.get(slotKey);
+    if (write.operation === "remove") edges?.delete(key);
+    else {
+      if (edges === void 0) listenerEdges.set(slotKey, edges = /* @__PURE__ */ new Map());
+      edges.set(key, write);
+    }
   }
   const externalListenerReceivers = /* @__PURE__ */ new Set();
-  for (const write of listenerEdges.values()) {
-    if (write.listener.valueId === null) continue;
-    const receiverGroup = groupByRowId.get(write.listener.valueId);
-    if (receiverGroup === void 0) continue;
-    const ownerGroup = groupByRowId.get(write.ownerId);
-    if (ownerGroup === void 0) {
-      if (rowForCleanup(write.ownerId) !== null)
-        externalListenerReceivers.add(receiverGroup);
-    } else {
-      let dependencies = state.constructorGroupDependencies.get(ownerGroup);
-      if (dependencies === void 0) {
-        dependencies = /* @__PURE__ */ new Set();
-        state.constructorGroupDependencies.set(ownerGroup, dependencies);
+  for (const edges of listenerEdges.values())
+    for (const write of edges.values()) {
+      if (write.listener.valueId === null) continue;
+      const receiverGroup = groupByRowId.get(write.listener.valueId);
+      if (receiverGroup === void 0) continue;
+      const ownerGroup = groupByRowId.get(write.ownerId);
+      if (ownerGroup === void 0) {
+        if (rowForCleanup(write.ownerId) !== null)
+          externalListenerReceivers.add(receiverGroup);
+      } else {
+        let dependencies = state.constructorGroupDependencies.get(ownerGroup);
+        if (dependencies === void 0) {
+          dependencies = /* @__PURE__ */ new Set();
+          state.constructorGroupDependencies.set(ownerGroup, dependencies);
+        }
+        dependencies.add(receiverGroup);
       }
-      dependencies.add(receiverGroup);
     }
-  }
   const markConstructorGroupEscaped = (rootId) => {
     if (escapedRoots.has(rootId)) return;
     escapedRoots.add(rootId);
@@ -17106,7 +17272,7 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
     const survivingWrites = state.writes.filter((write) => {
       if (write.kind === "changeListener") {
         if (collectedIds.has(write.ownerId)) return false;
-        return write.listener.valueId === null || !collectedIds.has(write.listener.valueId);
+        return write.operation === "clear" || write.listener.valueId === null || !collectedIds.has(write.listener.valueId);
       }
       const destination = write.resolvedDestination;
       const destinationId = destination !== void 0 && "containerValueId" in destination ? destination.containerValueId : void 0;
@@ -17680,6 +17846,7 @@ function validateTryInstruction(instruction) {
 function evalBody(body, scope, ctx, options, preparedFrame) {
   const state = ctx.__executionState;
   if (!state) return evalInstructions(body.instructions, scope, ctx, options);
+  const hostBody = state.frames.length === 0 && ctx.__getterSubscriptions !== void 0;
   state.frames.push(
     preparedFrame ?? {
       name: body.source?.name ?? "<body>",
@@ -17688,7 +17855,14 @@ function evalBody(body, scope, ctx, options, preparedFrame) {
     }
   );
   try {
-    return evalInstructions(body.instructions, scope, ctx, options);
+    if (!hostBody)
+      return evalInstructions(body.instructions, scope, ctx, options);
+    const result = evalInstructions(body.instructions, scope, ctx, {
+      ...options,
+      dispatchesGetterChanges: true
+    });
+    dispatchGetterSubscriptions(ctx);
+    return result;
   } catch (error) {
     attachNeoScriptTrace(error, state);
     throw error;
@@ -17852,7 +18026,8 @@ function evalInstructions(instructions, scope, ctx, options) {
           break;
         }
         case "addChangeListener" /* addChangeListener */:
-        case "removeChangeListener" /* removeChangeListener */: {
+        case "removeChangeListener" /* removeChangeListener */:
+        case "clearChangeListeners" /* clearChangeListeners */: {
           evalChangeListenerInstruction(ins, scope, ctx, options);
           break;
         }
@@ -18067,6 +18242,8 @@ function evalInstructions(instructions, scope, ctx, options) {
           return { kind: "continue" };
       }
       void touchUnknown(ins);
+      if (options.dispatchesGetterChanges === true)
+        dispatchGetterSubscriptions(ctx);
     } catch (error) {
       positionNeoScriptFrame(ctx, ins.source);
       if (ctx.__executionState)
@@ -18141,6 +18318,30 @@ function resolveNeoScriptChangeListenerSlot(ownerId, memberId, ctx) {
     typeInfo: changeListenerObservedType(raw, member, env, ctx)
   };
 }
+function resolveNeoScriptGetterListenerSlot(ownerId, memberId, ctx) {
+  const owner = evalValueById(
+    ctx,
+    ownerId,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  if (owner === null || owner.value === null) return null;
+  const entry = changeListenerMemberOnOwner(owner, memberId, ctx);
+  if (entry === void 0) return null;
+  const member = evalMemberById(ctx.vm, entry.memberId);
+  if (member === null || !isMemberNSProperty(member)) return null;
+  if (isStaticMember(member)) return null;
+  const env = runtimeGenericEnvForValueRow(owner, ctx, /* @__PURE__ */ new Set());
+  const typeInfo = substituteRuntimeTypeInfo(member.returnTypeInfo, env, ctx);
+  if (typeInfo.type === NS_TYPE_VOID) return null;
+  return {
+    owner,
+    member,
+    memberId: evaluatorResolutionCache(ctx).canonicalMemberId(member.id),
+    schemaKey: entry.schemaKey,
+    typeInfo
+  };
+}
 function changeListenerObservedType(raw, member, env, ctx) {
   const runtime = runtimeTypeInfoForMember(raw, env, ctx, /* @__PURE__ */ new Set());
   if (!isMemberLookup(member)) return runtime;
@@ -18163,6 +18364,18 @@ function changeListenerObservedType(raw, member, env, ctx) {
     required: isRequiredMember(member)
   };
 }
+function readNeoScriptChangeListenerValue(slot, ctx) {
+  const result = dispatchSchemaMember(
+    readRowValue(slot.owner, ctx),
+    slot.schemaKey,
+    ctx
+  );
+  if (result.kind !== "ok")
+    throw new NSGetterRuntimeError(
+      `OnChanged cannot read '${slot.owner.id}/${slot.memberId}'.`
+    );
+  return result.value;
+}
 function resolveNeoScriptChangeListenerHandler(slot, target, ctx) {
   const raw = evalMemberById(ctx.vm, target.memberId);
   if (raw === null) return null;
@@ -18224,15 +18437,29 @@ function evalChangeListenerInstruction(ins, scope, ctx, options) {
     throw new NSGetterRuntimeError(
       "OnChanged requires an existing logical owner."
     );
-  const slot = resolveNeoScriptChangeListenerSlot(
+  const stored = resolveNeoScriptChangeListenerSlot(
     owner.id,
     ins.target.memberId,
     ctx
   );
+  const getter = stored === null ? resolveNeoScriptGetterListenerSlot(owner.id, ins.target.memberId, ctx) : null;
+  const slot = stored ?? getter;
   if (slot === null)
     throw new NSGetterRuntimeError(
-      `OnChanged member '${ins.target.memberId}' is not an observable stored member of owner '${owner.id}'.`
+      `OnChanged member '${ins.target.memberId}' is not an observable member or getter of owner '${owner.id}'.`
     );
+  if (ins.type === "clearChangeListeners" /* clearChangeListeners */) {
+    if (getter !== null) clearGetterSubscription(getter, ctx);
+    else
+      options.writes.push({
+        kind: "changeListener",
+        target: ins.target,
+        ownerId: owner.id,
+        memberId: slot.memberId,
+        operation: "clear"
+      });
+    return;
+  }
   const listener = evalPointer(ins.listener, scope, ctx);
   if (!isMemberDelegateTarget(listener))
     throw new NSGetterRuntimeError(
@@ -18243,6 +18470,15 @@ function evalChangeListenerInstruction(ins, scope, ctx, options) {
     throw new NSGetterRuntimeError(
       `OnChanged handler '${listener.memberId}' cannot accept the value of '${slot.member.name}' on '${owner.id}'.`
     );
+  if (getter !== null) {
+    editGetterSubscription(
+      getter,
+      handler.target,
+      ins.type === "addChangeListener" /* addChangeListener */,
+      ctx
+    );
+    return;
+  }
   options.writes.push({
     kind: "changeListener",
     target: ins.target,
@@ -18252,6 +18488,106 @@ function evalChangeListenerInstruction(ins, scope, ctx, options) {
     listener: handler.target
   });
 }
+function editGetterSubscription(slot, target, add, ctx) {
+  if ((ctx.__executionState?.constructionStack.length ?? 0) > 0)
+    throw new NSGetterRuntimeError(
+      "A getter subscription lives only for the play session, so a constructor can't make one. Subscribe from a function."
+    );
+  const subscriptions = ctx.__getterSubscriptions;
+  if (subscriptions === void 0) return;
+  let subscription = subscriptions.get(slot.owner.id, slot.memberId);
+  const found = subscription?.targets.findIndex(
+    (existing) => existing.memberId === target.memberId && existing.valueId === target.valueId
+  ) ?? -1;
+  if (!add) {
+    if (subscription === void 0 || found < 0) return;
+    subscription.targets.splice(found, 1);
+    if (subscription.targets.length === 0) subscriptions.drop(subscription);
+    return;
+  }
+  if (found >= 0) return;
+  if (subscription === void 0) {
+    subscription = new NeoScriptGetterSubscription(
+      slot.owner.id,
+      slot.memberId,
+      slot.owner.classId
+    );
+    subscriptions.add(subscription);
+  }
+  subscription.targets.push(target);
+}
+function clearGetterSubscription(slot, ctx) {
+  if ((ctx.__executionState?.constructionStack.length ?? 0) > 0)
+    throw new NSGetterRuntimeError(
+      "A getter subscription lives only for the play session, so a constructor can't clear one. Clear from a function."
+    );
+  const subscriptions = ctx.__getterSubscriptions;
+  const subscription = subscriptions?.get(slot.owner.id, slot.memberId);
+  if (subscriptions === void 0 || subscription === void 0) return;
+  subscription.targets.length = 0;
+  subscriptions.drop(subscription);
+}
+function dispatchGetterSubscriptions(ctx) {
+  const subscriptions = ctx.__getterSubscriptions;
+  if (subscriptions === void 0) return;
+  const draining = subscriptions.takePending();
+  let next = 0;
+  try {
+    while (next < draining.length)
+      dispatchGetterSubscription(draining[next++], subscriptions, ctx);
+  } finally {
+    subscriptions.requeue(draining, next);
+  }
+}
+function dispatchGetterSubscription(subscription, subscriptions, ctx) {
+  subscription.queued = false;
+  const notify = !subscription.arming;
+  subscription.arming = false;
+  if (subscription.targets.length === 0) return;
+  const slot = resolveNeoScriptGetterListenerSlot(
+    subscription.rowId,
+    subscription.getterId,
+    ctx
+  );
+  if (slot === null || slot.owner.classId !== subscription.classId) {
+    subscriptions.drop(subscription);
+    return;
+  }
+  const reads = new InitializerReadSet();
+  let value;
+  try {
+    value = readNeoScriptChangeListenerValue(slot, {
+      ...ctx,
+      __getterReads: reads.valueIds,
+      containerDependencies: reads.containerIds,
+      staticMemberDependencies: reads.staticMemberIds,
+      worldQueryDependencies: reads.worldQueries,
+      onUnattributableValueRead: reads.recordUnattributableValueRead
+    });
+  } finally {
+    subscriptions.setReads(subscription, reads);
+  }
+  if (!notify) return;
+  const owner = readRowValue(slot.owner, ctx);
+  subscription.handling = true;
+  try {
+    for (const target of [...subscription.targets]) {
+      const handler = resolveNeoScriptChangeListenerHandler(slot, target, ctx);
+      if (handler === null) continue;
+      invokeDelegateValue(
+        handler.invocation,
+        [value],
+        ctx,
+        void 0,
+        owner,
+        "discarded",
+        () => dispatchGetterSubscriptions(ctx)
+      );
+    }
+  } finally {
+    subscription.handling = false;
+  }
+}
 function evalActionListenerInstruction(ins, scope, ctx, options) {
   const operator = ins.type === "addActionListener" /* addActionListener */ ? "+=" : "-=";
   if (ins.target.pointer.type === "variable" /* variable */) {
@@ -18428,6 +18764,7 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
     );
   }
   const bindings = writableStaticBindingMap(member, ctx);
+  ctx.__getterSubscriptions?.noteStaticBinding(member.id);
   if (value === null || value === void 0) {
     if (isRequiredMember(member)) {
       throw new NSGetterRuntimeError(
@@ -18466,7 +18803,7 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
         `Static member '${member.name}' is bound to missing value '${currentId}'.`
       );
     }
-    ctx.beforeValueWrite?.(row2);
+    observeValueWrite(ctx, row2);
     row2.value = value;
     row2.updatedAt = Date.now();
     invalidateEvaluatorIndexes(ctx);
@@ -25281,14 +25618,14 @@ function evalVariantApply(info, scope, ctx) {
     });
     for (const valueId of resolution.clearedValueIds) {
       const previous = readNeoScriptRuntimeRow(ctx, valueId);
-      if (previous) ctx.beforeValueWrite?.(previous);
+      if (previous) observeValueWrite(ctx, previous);
       deleteRuntimeSessionValue(ctx, valueId);
       ctx.__valueOverlay?.delete(valueId);
     }
     for (const row of resolution.rows) {
       if (row.id === rootRow.id) continue;
       const previous = readNeoScriptRuntimeRow(ctx, row.id);
-      if (previous) ctx.beforeValueWrite?.(previous);
+      if (previous) observeValueWrite(ctx, previous);
       ctx.__valueOverlay?.set(row.id, deepClonePlainData(row));
     }
     if (typeof receiver !== "object" || receiver === null || Array.isArray(receiver) || typeof resolution.root.value !== "object" || resolution.root.value === null || Array.isArray(resolution.root.value)) {
@@ -26506,7 +26843,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
         const edit = editChangeListenerSet(
           entry?.[write.memberId],
           [],
-          { kind: write.operation, target: write.listener },
+          changeListenerWriteEdit(write),
           { inheritedComplete: false }
         );
         if (!edit.changed) continue;
@@ -33731,6 +34068,15 @@ function inspectListenerAnnotation(annotation2, parameters) {
       return;
     }
     const parameter3 = parameters.byName.get(name);
+    if (!parameter3 && parameters.getters.has(name)) {
+      errors.push(
+        new CompileError(
+          `'${name}' is a getter. Getter listeners can't be authored. Subscribe with '+=' from a function.`,
+          expression.pos
+        )
+      );
+      return;
+    }
     if (!parameter3) {
       errors.push(
         new CompileError(
@@ -33774,7 +34120,10 @@ function createListenerAnnotationProvider(project, context = {}) {
     if (cached) return cached;
     const parameters = [];
     const byName = /* @__PURE__ */ new Map();
+    const getters = /* @__PURE__ */ new Set();
     for (const symbol of declaration.members) {
+      if (symbol.kind === "property" && symbol.computed === true && symbol.static !== true)
+        getters.add(symbol.name);
       if (!isChangeListenerSymbol(symbol)) continue;
       if (memberAccessFailure({ project, context, owner: declaration, symbol }))
         continue;
@@ -33798,7 +34147,8 @@ function createListenerAnnotationProvider(project, context = {}) {
     const result = {
       namedOnly: true,
       parameters,
-      byName
+      byName,
+      getters
     };
     cache.set(key, result);
     return result;
@@ -34020,6 +34370,7 @@ var WRITE_TARGET_DESCRIPTIONS = {
   projectValue: "a stored project value",
   unknown: "something other than `this` or a local"
 };
+var ON_CHANGED_OPERATIONS_ERROR = "OnChanged supports only '+=', '-=', and Clear().";
 var FALLTHROUGH_LABELS = {
   function: "NSFunction",
   getter: "getter",
@@ -35362,6 +35713,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           this.resolveExpression(statement.expr, scope);
         const debug = this.resolveDebugStatement(statement.expr, scope);
         if (debug) return debug;
+        const listenerClear = this.resolveChangeListenerClear(
+          statement.expr,
+          scope,
+          statement.pos
+        );
+        if (listenerClear) return listenerClear;
         const actionClear = this.resolveActionClear(
           statement.expr,
           scope,
@@ -35722,8 +36079,20 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       const observed = this.resolveExpression(statement.target.receiver, scope);
       const observedType = neoScriptMemberLookupType(observed.type);
       const declared = observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === "OnChanged");
-      if (!declared)
-        return this.resolveChangeSubscription(statement, observed, scope);
+      if (!declared) {
+        if (statement.op !== "+=" && statement.op !== "-=")
+          throw new CompileError(ON_CHANGED_OPERATIONS_ERROR, statement.pos);
+        return this.resolveChangeListener(
+          statement.target,
+          observed,
+          scope,
+          statement.pos,
+          {
+            kind: statement.op === "+=" ? "addChangeListener" /* AddChangeListener */ : "removeChangeListener" /* RemoveChangeListener */,
+            handler: statement.value
+          }
+        );
+      }
     }
     const local = statement.target.kind === "ident" ? scope.lookup(statement.target.name) : null;
     if (local?.readonlyBinding) {
@@ -35907,112 +36276,180 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pos
     );
   }
-  resolveChangeSubscription(statement, observed, scope) {
-    if (statement.op !== "+=" && statement.op !== "-=") {
-      throw new CompileError(
-        "OnChanged supports only '+=' and '-=' subscriptions.",
-        statement.pos
-      );
-    }
-    if (statement.target.kind !== "member") {
+  /** `X.M.OnChanged.Clear()` empties M's listener set on X (P70, P106). */
+  resolveChangeListenerClear(expression, scope, pos) {
+    if (expression.kind !== "call" || expression.callee.kind !== "member" || expression.callee.name !== "Clear" || expression.callee.receiver.kind !== "member" || expression.callee.receiver.name !== "OnChanged")
+      return null;
+    const onChanged = expression.callee.receiver;
+    const observed = this.resolveExpression(onChanged.receiver, scope);
+    const observedType = neoScriptMemberLookupType(observed.type);
+    if (observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === "OnChanged"))
+      return null;
+    if (expression.callee.optional)
       throw new CompileError(
-        "OnChanged requires a declared member slot.",
-        statement.pos
+        "OnChanged is never null, so optional-chained Clear is not supported.",
+        pos
       );
-    }
-    if (statement.target.optional) {
+    requireArgCount("Clear", expression.args, 0, pos);
+    return this.resolveChangeListener(onChanged, observed, scope, pos, {
+      kind: "clearChangeListeners" /* ClearChangeListeners */
+    });
+  }
+  resolveChangeListener(onChanged, observed, scope, pos, edit) {
+    if (onChanged.optional) {
       throw new CompileError(
         "OnChanged cannot use an optional subscription target.",
-        statement.pos
+        pos
       );
     }
     if (observed.optionalChainType !== void 0) {
       throw new CompileError(
         "OnChanged cannot subscribe through optional chaining; narrow the receiver first.",
-        statement.pos
+        pos
       );
     }
     const member = observed.symbol;
     if (!member)
       throw new CompileError(
         "OnChanged requires a declared member, not a local variable.",
-        statement.pos
+        pos
       );
-    if (observed.pointer.type !== "keyOf" /* KeyOf */)
+    if (observed.pointer.type === "staticMember" /* StaticMember */ || observed.pointer.type === "callGetter" /* CallGetter */ && observed.pointer.receiver.kind === "static") {
+      const access = onChanged.receiver;
+      const name = access.kind === "member" && access.receiver.kind === "ident" ? `${access.receiver.name}.${member.name}` : member.name;
       throw new CompileError(
-        "OnChanged requires a stored instance member, not a static member.",
-        statement.pos
+        `OnChanged requires an instance member. '${name}' is static.`,
+        pos
+      );
+    }
+    if (observed.pointer.type === "callGetter" /* CallGetter */)
+      return this.resolveGetterChangeListener(
+        onChanged.receiver,
+        observed,
+        observed.pointer,
+        member,
+        scope,
+        pos,
+        edit
       );
+    if (observed.pointer.type !== "keyOf" /* KeyOf */)
+      throw new CompileError("OnChanged requires a declared member slot.", pos);
     if (!observed.pointer.memberId)
       throw new CompileError(
         "OnChanged cannot observe a collection entry.",
-        statement.pos
+        pos
       );
     if (member.computed) {
       throw new CompileError(
         "OnChanged cannot observe a computed member.",
-        statement.pos
+        pos
       );
     }
     if (member.readonlyDeclaration) {
       throw new CompileError(
         "OnChanged cannot observe a readonly declaration.",
-        statement.pos
+        pos
       );
     }
     if (observed.type.kind === "delegate" || observed.type.kind === "action") {
       throw new CompileError(
         "OnChanged cannot observe a callable member.",
-        statement.pos
+        pos
       );
     }
     const writability = observed.userData ? "runtime" /* Runtime */ : observed.writability;
     if (writability !== "save" /* Save */ && writability !== "session" /* Session */ && writability !== "runtime" /* Runtime */ && writability !== "local" /* Local */) {
       throw new CompileError(
         "OnChanged requires a member whose storage is writable at gameplay runtime.",
-        statement.pos
+        pos
       );
     }
     this.validateConstructorWriteTarget(
       observed.pointer,
-      "subscribe to",
-      statement.pos,
+      edit.kind === "clearChangeListeners" /* ClearChangeListeners */ ? "clear listeners on" : "subscribe to",
+      pos,
       scope,
       false
     );
-    if (!statement.value) {
+    const storageType = this.assignmentStorageType(
+      onChanged.receiver,
+      observed,
+      null,
+      scope
+    );
+    return this.changeListenerInstruction(
+      edit,
+      {
+        owner: observed.pointer.keyOf.pointer,
+        memberId: member.canonicalMemberId ?? observed.pointer.memberId,
+        typeInfo: toWireType(storageType, this.project),
+        writability
+      },
+      storageType,
+      scope,
+      pos
+    );
+  }
+  /**
+   * P106. A getter subscription lives only in the running client's memory:
+   * nothing persists it, so construction replay would silently drop one.
+   */
+  resolveGetterChangeListener(getterRead, observed, pointer, member, scope, pos, edit) {
+    if (pointer.dispatch === "base") {
       throw new CompileError(
-        "OnChanged subscription requires a handler member.",
-        statement.pos
+        `OnChanged can't observe a base getter. Subscribe to '${member.name}' on the instance.`,
+        pos
       );
     }
-    const storageType = this.assignmentStorageType(
-      statement.target.receiver,
+    if (pointer.receiver.kind !== "instance") {
+      throw new CompileError(
+        `OnChanged requires an instance receiver for getter '${member.name}'.`,
+        pos
+      );
+    }
+    const kind = this.context.kind;
+    if (isNeoScriptConstructionDocumentKind(kind) || kind === "migration") {
+      throw new CompileError(
+        edit.kind === "clearChangeListeners" /* ClearChangeListeners */ ? `A getter subscription lives only for the play session, so ${dialogueBodyKindLabel(kind)} can't clear one. Clear from a function.` : `A getter subscription lives only for the play session, so ${dialogueBodyKindLabel(kind)} can't make one. Subscribe from a function.`,
+        pos
+      );
+    }
+    const getterType = this.assignmentStorageType(
+      getterRead,
       observed,
       null,
       scope
     );
-    const expected = {
-      kind: "action",
-      parameterTypes: [storageType]
-    };
+    return this.changeListenerInstruction(
+      edit,
+      {
+        owner: pointer.receiver.pointer,
+        memberId: member.canonicalMemberId ?? pointer.memberId,
+        typeInfo: toWireType(getterType, this.project),
+        writability: "session" /* Session */
+      },
+      getterType,
+      scope,
+      pos
+    );
+  }
+  changeListenerInstruction(edit, target, observedType, scope, pos) {
+    if (edit.kind === "clearChangeListeners" /* ClearChangeListeners */)
+      return { type: edit.kind, target };
+    if (!edit.handler) {
+      throw new CompileError(
+        "OnChanged subscription requires a handler member.",
+        pos
+      );
+    }
     const listener = this.resolveActionListener(
-      statement.value,
-      expected,
+      edit.handler,
+      { kind: "action", parameterTypes: [observedType] },
       scope,
       true,
       true
     );
-    return {
-      type: statement.op === "+=" ? "addChangeListener" /* AddChangeListener */ : "removeChangeListener" /* RemoveChangeListener */,
-      target: {
-        owner: observed.pointer.keyOf.pointer,
-        memberId: member.canonicalMemberId ?? observed.pointer.memberId,
-        typeInfo: toWireType(storageType, this.project),
-        writability
-      },
-      listener
-    };
+    return { type: edit.kind, target, listener };
   }
   /**
    * P62 §3.2. `+=` / `-=` on an NSAction member are subscription operators,
@@ -38130,6 +38567,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         entryUserData
       };
     }
+    if (name === "OnChanged")
+      throw new CompileError(ON_CHANGED_OPERATIONS_ERROR, pos);
     throw new CompileError(
       `Cannot read member '${name}' on ${this.describe(receiver.type)}`,
       pos
@@ -51186,7 +51625,7 @@ var ACTION_LISTENER_TARGET_KINDS = /* @__PURE__ */ new Set([
   26 /* NSAction */
 ]);
 
-// node_modules/valibot/dist/index.mjs
+// ../node_modules/valibot/dist/index.mjs
 var store$4;
 var DEFAULT_CONFIG = {
   lang: void 0,
@@ -51274,18 +51713,6 @@ function _standardSchema(schema) {
   };
   return schema;
 }
-var ValiError = class extends Error {
-  /**
-  * Creates a Valibot error with useful information.
-  *
-  * @param issues The error issues.
-  */
-  constructor(issues) {
-    super(issues[0].message);
-    this.name = "ValiError";
-    this.issues = issues;
-  }
-};
 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");
 // @__NO_SIDE_EFFECTS__
 function check(requirement, message$1) {
@@ -51956,11 +52383,6 @@ function variant(key, options, message$1) {
     }
   });
 }
-function parse2(schema, input, config$1) {
-  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
-  if (dataset.issues) throw new ValiError(dataset.issues);
-  return dataset.value;
-}
 // @__NO_SIDE_EFFECTS__
 function pipe(...pipe$1) {
   return _standardSchema({
@@ -52584,6 +53006,43 @@ var schemaMemberSchema = variant("kind", [
   })
 ]);
 
+// node_modules/valibot/dist/index.mjs
+var store$42;
+var DEFAULT_CONFIG2 = {
+  lang: void 0,
+  message: void 0,
+  abortEarly: void 0,
+  abortPipeEarly: void 0
+};
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig2(config$1) {
+  if (!config$1 && !store$42) return DEFAULT_CONFIG2;
+  return {
+    lang: config$1?.lang ?? store$42?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$42?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$42?.abortPipeEarly
+  };
+}
+var ValiError = class extends Error {
+  /**
+  * Creates a Valibot error with useful information.
+  *
+  * @param issues The error issues.
+  */
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
+var EMOJI_REGEX2 = 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 parse2(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig2(config$1));
+  if (dataset.issues) throw new ValiError(dataset.issues);
+  return dataset.value;
+}
+
 // ../packages/neoscript-language/src/docs-text.ts
 var DOCS_TEXT_MAX_UTF8_BYTES2 = 16384;
 function docsTextUtf8ByteLength(value) {
@@ -55288,7 +55747,7 @@ var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.73.2",
+  cliVersion: "0.75.0",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -57010,7 +57469,7 @@ var PRESIGN_BATCH_SIZE = Math.min(
   PROJECT_FILE_UPLOAD_BATCH_SIZE
 );
 
-// node_modules/@formatjs/icu-messageformat-parser/index.js
+// ../node_modules/@formatjs/icu-messageformat-parser/index.js
 var SPACE_SEPARATOR_REGEX = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;
 var IDENTIFIER_PREFIX_REGEX = /([^\t-\r -\/:-@\[-\^`\{-~\x85\xA0-\xA7\xA9\xAB\xAC\xAE\xB0\xB1\xB6\xBB\xBF\xD7\xF7\u1680\u2000-\u200A\u2010-\u2029\u202F-\u203E\u2041-\u2053\u2055-\u205F\u2190-\u245F\u2500-\u2775\u2794-\u2BFF\u2E00-\u2E7F\u3000-\u3003\u3008-\u3020\u3030\uFD3E\uFD3F\uFE45\uFE46]*)/g;
 var SPACE_SEPARATOR_START_REGEX = new RegExp(`^${SPACE_SEPARATOR_REGEX.source}*`);
@@ -57270,7 +57729,8 @@ function makeEvaluatorContext(rawDocument, interceptor) {
     rootValue: base.rootValue,
     dialogueContext: null,
     callInterceptor: interceptor,
-    nativeFunctionErrorCheckBehavior: "strict"
+    nativeFunctionErrorCheckBehavior: "strict",
+    getterDispatch: "afterEntryStatement" /* AfterEntryStatement */
   });
 }
 function createSpecCompiler(document2) {
@@ -57844,6 +58304,7 @@ function copyMocks(source, target) {
 function cloneTestEnvironment(source) {
   const cloned = createTestEnvironment(snapshotEnvironmentDocument(source));
   copyMocks(source, cloned);
+  cloned.context.__getterSubscriptions = source.context.__getterSubscriptions?.clone();
   return cloned;
 }
 function runCallback(environment, delegate, deadlineMs) {