@velarscript/web 0.12.0 → 0.13.0

package/dist/runtime-foundation.js

@@ -432,6 +432,8 @@ const __velarGraphNativeWeakMap = globalThis.WeakMap;
 const __velarGraphNativeProxy = globalThis.Proxy;
 const __velarGraphReflectApply = Object.getOwnPropertyDescriptor(Reflect, "apply")?.value;
 const __velarGraphArrayIsArray = Object.getOwnPropertyDescriptor(Array, "isArray")?.value;
+const __velarGraphArrayPrototype = Object.getOwnPropertyDescriptor(__velarGraphNativeArray, "prototype")?.value;
+const __velarGraphArraySort = __velarGraphArrayPrototype && Object.getOwnPropertyDescriptor(__velarGraphArrayPrototype, "sort")?.value;
 const __velarGraphObjectIs = Object.getOwnPropertyDescriptor(Object, "is")?.value;
 const __velarGraphObjectFreeze = Object.getOwnPropertyDescriptor(Object, "freeze")?.value;
 const __velarGraphObjectDefineProperty = Object.getOwnPropertyDescriptor(Object, "defineProperty")?.value;
@@ -509,6 +511,7 @@ function __velarGraphWeakMapRead(value, key) { return __velarGraphApply(__velarG
 function __velarGraphWeakMapWrite(value, key, item) { return __velarGraphApply(__velarGraphWeakMapSet, value, [key, item], "WeakMap.set"); }
 function __velarGraphWeakMapRemove(value, key) { return __velarGraphApply(__velarGraphWeakMapDelete, value, [key], "WeakMap.delete"); }
 function __velarGraphIsList(value) { return __velarGraphApply(__velarGraphArrayIsArray, __velarGraphNativeArray, [value], "Array.isArray"); }
+function __velarGraphOrder(value, compare) { return __velarGraphApply(__velarGraphArraySort, value, [compare], "Array.sort"); }
 function __velarGraphSame(left, right) { return __velarGraphApply(__velarGraphObjectIs, __velarGraphNativeObject, [left, right], "Object.is"); }
 function __velarGraphFreeze(value) { return __velarGraphApply(__velarGraphObjectFreeze, __velarGraphNativeObject, [value], "Object.freeze"); }
 function __velarGraphDefine(value, key, descriptor) { return __velarGraphApply(__velarGraphObjectDefineProperty, __velarGraphNativeObject, [value, key, descriptor], "Object.defineProperty"); }
@@ -630,6 +633,239 @@ function __velarReportOptions(value) {
   return output;
 }
 
+// D90 R21: the number stamped on each observer when it is created, and the
+// order the flush runs the watch tier in -- execution order is the order the
+// author wrote the watches, and "wrote" spans more than one file: watches of
+// one module register as that module initializes, instances of one component
+// register as they mount, and modules register in the order the import graph
+// initializes them. Every one of those is registration order, so one counter
+// answers all three.
+//
+// It has to be application-wide, not per module. Each emitted module carries
+// its own copy of this runtime, so a module-scope counter would restart at zero
+// in the second module and the two modules' watches would compare equal. The
+// counter therefore lives on one global slot every copy reads, the same way the
+// runtime registry itself does.
+const __velarObserverSequenceKey = Symbol.for("velar.web.observer.sequence.v1");
+const __velarObserverSequenceCell = (() => {
+  const descriptor = __velarGraphOwnDescriptor(globalThis, __velarObserverSequenceKey);
+  if (descriptor) {
+    if (!("value" in descriptor) || descriptor.enumerable || descriptor.configurable || descriptor.writable
+      || !__velarGraphIsList(descriptor.value)) {
+      throw new TypeError("VelarScript Web observer sequence ownership is invalid");
+    }
+    return descriptor.value;
+  }
+  const cell = [0];
+  __velarGraphDefine(globalThis, __velarObserverSequenceKey, {
+    value: cell,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+  return cell;
+})();
+
+function __velarNextObserverSequence() {
+  __velarObserverSequenceCell[0] += 1;
+  return __velarObserverSequenceCell[0];
+}
+
+// The identity a flush stamps its run counts with, carried by an overrun into
+// the flush it schedules and consumed by the first flush that starts.
+let __velarOverflowToken = null;
+
+// The three observers that have run most in the settle running now, kept as
+// the run counts are stamped rather than reconstructed afterwards: the queue at
+// the moment the budget runs out holds only whichever half of a cycle has not
+// just run, so it cannot name the ring on its own. An observer that has run
+// once is not a candidate, which is every observer of an ordinary flush.
+const __velarFlushLeaders = [];
+
+function __velarFlushLead(observer) {
+  let kept = 0;
+  for (let index = 0; index < __velarFlushLeaders.length; index += 1) {
+    if (__velarFlushLeaders[index] === observer) continue;
+    __velarFlushLeaders[kept] = __velarFlushLeaders[index];
+    kept += 1;
+  }
+  __velarFlushLeaders.length = kept;
+  let position = kept;
+  while (position > 0 && __velarFlushLeaders[position - 1].flushRuns < observer.flushRuns) {
+    __velarFlushLeaders[position] = __velarFlushLeaders[position - 1];
+    position -= 1;
+  }
+  __velarFlushLeaders[position] = observer;
+  if (__velarFlushLeaders.length > 3) __velarFlushLeaders.length = 3;
+}
+
+// D90 R21: compile time no longer refuses two watches that write one state, so
+// this budget is the only gate left against a mutual-write cycle -- and a
+// report that names nobody hands the author a number with no line to go to.
+// The observers that ran most in this flush chain are the cycle; flushRuns
+// already counts exactly that, so the highest few are named. A watch's label is
+// its subject as the author spelled it, which in a write cycle is also the
+// state each watch is reacting to, and the scope it was registered in supplies
+// the component the report has always had a field for.
+//
+// Nothing here asks who wrote what. That question is gone from the language,
+// and answering it would need the write frames R21 deleted.
+function __velarFlushRunaway(stalled, token) {
+  const ranked = [];
+  const seen = __velarGraphCreateSet();
+  const consider = (observer) => {
+    if (observer.flushToken !== token || __velarGraphSetContains(seen, observer)) return;
+    __velarGraphSetInsert(seen, observer);
+    ranked[ranked.length] = observer;
+  };
+  // A cycle alternates, so the queue at the instant the budget ran out holds
+  // only the half of the ring that has not just run. The leaders carry the
+  // other half.
+  for (let index = 0; index < __velarFlushLeaders.length; index += 1) consider(__velarFlushLeaders[index]);
+  for (let index = 0; index < stalled.length; index += 1) consider(stalled[index]);
+  __velarGraphOrder(ranked, (left, right) => right.flushRuns - left.flushRuns);
+  const limit = ranked.length < 3 ? ranked.length : 3;
+  let detail = "";
+  let component = "";
+  for (let index = 0; index < limit; index += 1) {
+    const observer = ranked[index];
+    const named = observer.mode === "watch" && typeof observer.label === "string" && observer.label !== ""
+      ? "the watch on '" + observer.label + "'"
+      : "a " + observer.mode + " observer";
+    detail += (detail === "" ? "Ran most in this flush: " : ", ") + named
+      + " (" + observer.flushRuns + (observer.flushRuns === 1 ? " run)" : " runs)");
+    if (component === "" && typeof observer.component === "string") component = observer.component;
+  }
+  return { detail, component };
+}
+
+function __velarScheduleFlush() {
+  if (__velarRuntime.flushPending) return;
+  __velarRuntime.flushPending = true;
+  __velarEnqueue(__velarFlush);
+}
+
+// Only the observers that actually re-entered the queue during the overrun
+// belong to the runaway cycle. An observer queued once by an unrelated write
+// in the same turn is innocent, and stopping it is irreversible, so it is
+// put back for the next microtask instead.
+//
+// Every overrun must still remove something, or the requeue turns the
+// microtask chain into the freeze the budget exists to end: a cycle spread
+// across more observers than the budget can run four times over re-enters
+// none of them four times, so a fixed threshold of four stops nobody and the
+// next flush repeats it forever. Two rules make the progress unconditional.
+// The threshold falls to the highest run count actually present, so any
+// queued observer this flush chain has already run is stopped; and the token
+// is carried into the flush the overrun schedules, so run counts accumulate
+// across the chain and the observers the chain has not reached yet are a
+// pool that only shrinks.
+function __velarFlushOverflow(token) {
+  const stalled = [];
+  for (const observer of __velarGraphSetItems(__velarRuntime.domQueue)) stalled[stalled.length] = observer;
+  for (const observer of __velarGraphSetItems(__velarRuntime.watchQueue)) stalled[stalled.length] = observer;
+  __velarGraphSetEmpty(__velarRuntime.domQueue);
+  __velarGraphSetEmpty(__velarRuntime.watchQueue);
+  let threshold = 0;
+  for (let index = 0; index < stalled.length; index += 1) {
+    const observer = stalled[index];
+    if (observer.flushToken === token && observer.flushRuns > threshold) threshold = observer.flushRuns;
+  }
+  if (threshold > 4) threshold = 4;
+  let requeued = false;
+  for (let index = 0; index < stalled.length; index += 1) {
+    const observer = stalled[index];
+    if (threshold > 0 && observer.flushToken === token && observer.flushRuns >= threshold) {
+      if (typeof observer.stop === "function") observer.stop();
+      else observer.stopped = true;
+      continue;
+    }
+    if (observer.stopped) continue;
+    __velarGraphSetInsert(observer.mode === "watch" ? __velarRuntime.watchQueue : __velarRuntime.domQueue, observer);
+    requeued = true;
+  }
+  const runaway = __velarFlushRunaway(stalled, token);
+  __velarRuntime.report(new RangeError("Reactive updates cannot run more than 100000 observers in one flush"),
+    { phase: "update", detail: runaway.detail, component: runaway.component, unhandled: true });
+  if (requeued) {
+    __velarOverflowToken = token;
+    __velarScheduleFlush();
+  }
+}
+
+// The one entry point: the microtask __velarScheduleFlush enqueues, and the
+// synchronous drain the emitted tick() performs. It used to open and close D90
+// R1-a-scope's flush-scoped writer registry around the settle; R21 deleted the
+// registry with the referee that read it, so the name is all that remains and
+// it remains because __velarEnqueue and tick() both hold it.
+function __velarFlush() {
+  __velarFlushSettle();
+}
+
+// Glitch-free order: every derived value and every watch settles to a fixed
+// point before a single DOM node is written, so no watch and no rendered
+// position can read a half-updated world and no corrective watch can push an
+// invalid value through the DOM first. That is D90 R1 and it is unchanged.
+//
+// D90 R21 changed the other axis. Within the settle the watches run in
+// registration order -- source order in a module, mount order across instances
+// of one component, module-initialization order across modules -- and a watch
+// that writes state is not promoted ahead of one that only observes. Whoever is
+// written first runs first, two watches writing one state both take effect in
+// that order, and a later write that clobbers an earlier one is the author's.
+//
+// Queue insertion order is not registration order and cannot stand in for it:
+// two watches on two different states, both dirtied by one action, enter the
+// queue in the order the action wrote the states. So each pass takes the queue
+// as it stands and runs it by sequence number. Watches queued by this pass are
+// picked up by the next one, in their own order.
+function __velarFlushSettle() {
+  __velarRuntime.flushPending = false;
+  const token = __velarOverflowToken === null ? {} : __velarOverflowToken;
+  __velarOverflowToken = null;
+  __velarFlushLeaders.length = 0;
+  let budget = 100000;
+  const step = (observer) => {
+    __velarGraphSetRemove(observer.mode === "watch" ? __velarRuntime.watchQueue : __velarRuntime.domQueue, observer);
+    if (observer.flushToken === token) observer.flushRuns += 1;
+    else { observer.flushToken = token; observer.flushRuns = 1; }
+    if (observer.flushRuns > 1) __velarFlushLead(observer);
+    observer.run();
+  };
+  while (__velarGraphSetCount(__velarRuntime.domQueue) || __velarGraphSetCount(__velarRuntime.watchQueue)) {
+    while (true) {
+      let ran = false;
+      for (const observer of __velarGraphSetItems(__velarRuntime.domQueue)) {
+        if (observer.mode !== "computed") continue;
+        if ((budget -= 1) < 0) { __velarFlushOverflow(token); return; }
+        step(observer);
+        ran = true;
+      }
+      if (ran) continue;
+      const pending = [];
+      for (const observer of __velarGraphSetItems(__velarRuntime.watchQueue)) pending[pending.length] = observer;
+      __velarGraphOrder(pending, (left, right) => left.sequence - right.sequence);
+      for (let index = 0; index < pending.length; index += 1) {
+        const observer = pending[index];
+        // A watch this pass already re-ran or stopped is no longer queued; the
+        // snapshot is a plan, and the queue is what says whether it still owes
+        // a run.
+        if (observer.stopped || !__velarGraphSetContains(__velarRuntime.watchQueue, observer)) continue;
+        if ((budget -= 1) < 0) { __velarFlushOverflow(token); return; }
+        step(observer);
+        ran = true;
+      }
+      if (!ran) break;
+    }
+    for (const observer of __velarGraphSetItems(__velarRuntime.domQueue)) {
+      if (observer.mode === "computed") break;
+      if ((budget -= 1) < 0) { __velarFlushOverflow(token); return; }
+      step(observer);
+    }
+  }
+  if (__velarGraphSetCount(__velarRuntime.domQueue) || __velarGraphSetCount(__velarRuntime.watchQueue)) __velarScheduleFlush();
+}
+
 function __velarCreateRuntime() {
   const runtime = Object.create(null);
   const domQueue = Object.freeze(__velarGraphCreateSet());
@@ -756,14 +992,23 @@ function __velarCreateRuntime() {
   };
   const link = (child, parent) => {
     if (child === null || (typeof child !== "object" && typeof child !== "function")) return;
-    linkOwner(toRaw(child), parent);
+    linkOwner(toRaw(child), parent, true);
   };
-  const linkOwner = (child, parent) => {
+  // 'structural' separates a slot being filled from a slot merely being read.
+  // A read proves the child is in the parent right now; only a write adds an
+  // occurrence, and only a write can create the duplicate the running count
+  // cannot see for itself.
+  const linkOwner = (child, parent, structural = false) => {
     parent = toRaw(parent);
     if (parent === null || (typeof parent !== "object" && typeof parent !== "function") || child === parent) return;
     let owners = __velarGraphWeakMapRead(parents, child);
     if (!owners) { owners = __velarGraphCreateSet(); __velarGraphWeakMapWrite(parents, child, owners); }
+    const known = __velarGraphSetContains(owners, parent);
     __velarGraphSetInsert(owners, parent);
+    const counts = __velarGraphWeakMapRead(containment, parent);
+    if (!counts) return;
+    if (structural && known) { __velarGraphWeakMapRemove(containment, parent); return; }
+    if ((__velarGraphMapRead(counts, child) ?? 0) < 1) __velarGraphMapWrite(counts, child, 1);
   };
   // Removing the last owner of a value detaches everything only that value
   // owned. Without the cascade, replacing a state root leaves every surviving
@@ -850,43 +1095,74 @@ function __velarCreateRuntime() {
       if (value !== null && (typeof value === "object" || typeof value === "function")) visit(value);
     }
   };
-  const contains = (parent, child) => {
-    parent = toRaw(parent);
-    child = toRaw(child);
+  // Containment used to be re-derived by scanning the whole container on every
+  // element write, which made one assignment into a rendered List cost O(list
+  // length). The occurrence index answers the same question -- does the parent
+  // still reference this child anywhere? -- in constant time: it is built once
+  // from the container's real contents and then maintained by the same link and
+  // release calls that change them.
+  const containment = __velarGraphCreateWeakMap();
+  const countOccurrence = (counts, value) => {
+    value = toRaw(value);
+    if (value === null || (typeof value !== "object" && typeof value !== "function")) return;
+    __velarGraphMapWrite(counts, value, (__velarGraphMapRead(counts, value) ?? 0) + 1);
+  };
+  // Mirrors exactly what the old scan looked at, Map keys included as owned
+  // values are, so the index cannot answer a question the scan answered
+  // differently.
+  const buildContainment = (parent) => {
+    const counts = __velarGraphCreateMap();
     if (__velarGraphIsList(parent)) {
-      for (let index = 0; index < parent.length; index += 1) {
-        if (toRaw(__velarGraphOwnDescriptor(parent, index)?.value) === child) return true;
-      }
-      return false;
+      for (let index = 0; index < parent.length; index += 1) countOccurrence(counts, __velarGraphOwnDescriptor(parent, index)?.value);
+      return counts;
     }
     const brand = collectionBrand(parent);
     if (brand === 1) {
-      for (const value of __velarGraphMapItems(parent)) if (toRaw(value) === child) return true;
-      return false;
+      for (const value of __velarGraphMapItems(parent)) countOccurrence(counts, value);
+      return counts;
     }
     if (brand === 2) {
-      for (const value of __velarGraphSetItems(parent)) if (toRaw(value) === child) return true;
-      return false;
+      for (const value of __velarGraphSetItems(parent)) countOccurrence(counts, value);
+      return counts;
     }
-    if (!parent || typeof parent !== "object") return false;
+    if (!parent || typeof parent !== "object") return counts;
     for (const name of __velarGraphOwnNames(parent)) {
       const descriptor = __velarGraphOwnDescriptor(parent, name);
-      if (descriptor && "value" in descriptor && toRaw(descriptor.value) === child) return true;
+      if (descriptor && "value" in descriptor) countOccurrence(counts, descriptor.value);
     }
-    return false;
+    return counts;
   };
   // The one guard every detach path shares: a primitive was never linked, and
   // an object with no owners has nothing to release, so neither may reach the
-  // O(fields) containment scan.
+  // containment bookkeeping.
   const releaseChild = (parent, child) => {
     if (child === null || (typeof child !== "object" && typeof child !== "function")
       || !__velarGraphWeakMapContains(parents, child)) return;
-    if (!contains(parent, child)) unlink(child, parent);
+    parent = toRaw(parent);
+    if (parent === null || (typeof parent !== "object" && typeof parent !== "function")) return;
+    child = toRaw(child);
+    // A freshly built index already reflects the slot that was just cleared;
+    // a maintained one still counts it, so only that one takes the decrement.
+    let counts = __velarGraphWeakMapRead(containment, parent);
+    let remaining;
+    if (counts) remaining = (__velarGraphMapRead(counts, child) ?? 0) - 1;
+    else {
+      counts = buildContainment(parent);
+      __velarGraphWeakMapWrite(containment, parent, counts);
+      remaining = __velarGraphMapRead(counts, child) ?? 0;
+    }
+    if (remaining > 0) { __velarGraphMapWrite(counts, child, remaining); return; }
+    __velarGraphMapRemove(counts, child);
+    unlink(child, parent);
   };
-  const reactive = (value, parent = null) => {
+  // The registry operation stays exactly two parameters wide; 'structural'
+  // belongs to the internal call, which knows whether a slot is being filled or
+  // merely read, and every caller outside this file fills one.
+  const reactive = (value, parent = null) => reactiveValue(value, parent, true);
+  const reactiveValue = (value, parent, structural) => {
     if (value === null || (typeof value !== "object" && typeof value !== "function")) return value;
     value = toRaw(value);
-    if (parent !== null) linkOwner(value, parent);
+    if (parent !== null) linkOwner(value, parent, structural);
     if (typeof value !== "object" || __velarGraphIsList(value) || !__velarGraphIsExtensible(value)) return value;
     const prototype = __velarGraphPrototype(value);
     if (prototype !== __velarGraphNativeObject.prototype && prototype !== null) return value;
@@ -895,7 +1171,7 @@ function __velarCreateRuntime() {
     proxy = new __velarGraphNativeProxy(value, {
       get(target, key) {
         track(target, key);
-        return reactive(__velarGraphGet(target, key, target), target);
+        return reactiveValue(__velarGraphGet(target, key, target), target, false);
       },
       set(target, key, next) {
         next = toRaw(next);
@@ -941,7 +1217,7 @@ function __velarCreateRuntime() {
     // through them. Fresh derived Lists (filter/map/etc.) stay ephemeral and
     // cannot become strongly retained parents of every item merely by being
     // iterated during rendering.
-    return reactive(child, __velarGraphWeakMapContains(parents, value) ? value : null);
+    return reactiveValue(child, __velarGraphWeakMapContains(parents, value) ? value : null, false);
   };
   const collectionTrigger = (value, key, iterate = true, structure = false, indexFrom = null, allKeys = false) => trigger(toRaw(value), key, iterate, structure, indexFrom, allKeys);
   const collectionUnlink = (value, child) => {
@@ -1115,52 +1391,17 @@ function __velarCreateRuntime() {
     try { report(error, { phase: "update", detail: "", component: "", unhandled: true }); }
     finally { runtime.activeObserver = previousObserver; }
   };
-  // The scheduler lives on the runtime registry itself: computed observers are
-  // created by whichever module stamped the registry first (velar/app under
-  // ESM import order, or the application prelude), and their notifications
-  // must schedule correctly no matter which module that was. The emitted
-  // application prelude keeps its own identical drain for the observers it
-  // creates; the shared flushPending flag keeps exactly one flush microtask
-  // enqueued whichever side scheduled first, and either drain runs every
-  // queued observer.
-  const scheduleFlush = () => {
-    if (runtime.flushPending) return;
-    runtime.flushPending = true;
-    __velarEnqueue(flush);
-  };
-  const flushOverflow = () => {
-    const stalled = [];
-    for (const observer of __velarGraphSetItems(domQueue)) stalled[stalled.length] = observer;
-    for (const observer of __velarGraphSetItems(watchQueue)) stalled[stalled.length] = observer;
-    __velarGraphSetEmpty(domQueue);
-    __velarGraphSetEmpty(watchQueue);
-    for (let index = 0; index < stalled.length; index += 1) {
-      const observer = stalled[index];
-      if (typeof observer.stop === "function") observer.stop();
-      else observer.stopped = true;
-    }
-    report(new RangeError("Reactive updates cannot run more than 100000 observers in one flush"), { phase: "update", detail: "", component: "", unhandled: true });
-  };
-  const flush = () => {
-    runtime.flushPending = false;
-    let budget = 100000;
-    for (const observer of __velarGraphSetItems(domQueue)) {
-      __velarGraphSetRemove(domQueue, observer);
-      if ((budget -= 1) < 0) { flushOverflow(); return; }
-      observer.run();
-    }
-    for (const observer of __velarGraphSetItems(watchQueue)) {
-      __velarGraphSetRemove(watchQueue, observer);
-      if ((budget -= 1) < 0) { flushOverflow(); return; }
-      observer.run();
-    }
-    if (__velarGraphSetCount(domQueue) || __velarGraphSetCount(watchQueue)) scheduleFlush();
-  };
+  // The queue insert stays on the registry -- computed observers are created by
+  // whichever module stamped it first (velar/app under ESM import order, or the
+  // application prelude) and must schedule correctly whichever that was -- but
+  // the drain it calls is the module-scope one below, and there is now exactly
+  // one of those. A queue that outgrows its bound is the flush budget's failure
+  // to own, not an exception thrown out of the assignment that happened to
+  // cross the line: throwing here left the writing cell's subscriber walk half
+  // finished, with the remaining observers subscribed and never notified again.
   const schedule = (observer) => {
-    const queue = observer.mode === "watch" ? watchQueue : domQueue;
-    if (!__velarGraphSetContains(queue, observer) && __velarGraphSetCount(queue) >= 100000) throw new RangeError("VelarScript reactive queues cannot exceed 100000 observers");
-    __velarGraphSetInsert(queue, observer);
-    scheduleFlush();
+    __velarGraphSetInsert(observer.mode === "watch" ? watchQueue : domQueue, observer);
+    __velarScheduleFlush();
   };
   const applyLook = (...arguments_) => {
     if (!lookImplementation) throw new TypeError("Link Look requires the VelarScript Web runtime");
@@ -1188,7 +1429,18 @@ function __velarCreateRuntime() {
 }
 
 function __velarRequireRuntime(value) {
-  if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== null || Object.isExtensible(value)
+  if (!value || typeof value !== "object") throw new TypeError("VelarScript Web runtime ownership is invalid");
+  // The schema comparison comes first, ahead of ownership and the field roster:
+  // a schema bump normally changes the roster too, so leaving it last reported
+  // "fields are invalid" and never named the one fact that identifies the
+  // cause. The version is read through its descriptor rather than the property
+  // so an unvalidated object cannot answer it with a getter.
+  const __velarVersionDescriptor = Object.getOwnPropertyDescriptor(value, "version");
+  const __velarVersion = __velarVersionDescriptor && "value" in __velarVersionDescriptor ? __velarVersionDescriptor.value : undefined;
+  if (__velarVersion !== ${JSON.stringify(VELAR_RUNTIME_SCHEMA_VERSION)}) {
+    throw new TypeError("VelarScript Web runtime schema " + (typeof __velarVersion === "string" ? __velarVersion : "(unknown)") + " does not match this module's schema ${VELAR_RUNTIME_SCHEMA_VERSION}; one build mixed two generations of @velarscript/* — run 'npm ls @velarscript/compiler' and pin one version");
+  }
+  if (Object.getPrototypeOf(value) !== null || Object.isExtensible(value)
     || Object.getOwnPropertySymbols(value).length > 0) throw new TypeError("VelarScript Web runtime ownership is invalid");
   const names = Object.getOwnPropertyNames(value);
   if (names.length !== __velarRuntimeFields.length || __velarRuntimeFields.some((name) => !names.includes(name))) {
@@ -1201,8 +1453,7 @@ function __velarRequireRuntime(value) {
       throw new TypeError("VelarScript Web runtime field '" + name + "' is invalid");
     }
   }
-  if (value.version !== ${JSON.stringify(VELAR_RUNTIME_SCHEMA_VERSION)}
-    || !__velarRuntimeCollection(value.domQueue, "Set") || !__velarRuntimeCollection(value.watchQueue, "Set")
+  if (!__velarRuntimeCollection(value.domQueue, "Set") || !__velarRuntimeCollection(value.watchQueue, "Set")
     || typeof value.flushPending !== "boolean" || (value.activeObserver !== null && typeof value.activeObserver !== "object")
     || !__velarRuntimeCollection(value.errorHandlers, "Set") || !__velarRuntimeCollection(value.actionFailures, "WeakSet")
     || !__velarRuntimeCollection(value.unhandledFailures, "Set")

package/dist/runtime-foundation.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-foundation.js","sourceRoot":"","sources":["../src/runtime-foundation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EACjC,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,iCAAiC,CAAC;AAEzC,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsa7C,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGpD,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;CAyBpD,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,iCAAiC,KAAK,2BAA2B,EAAE,CAAC;AAE7G,SAAS,oBAAoB,CAAC,gBAAwB;IACpD,OAAO,MAAM,CAAC,GAAG,CAAA;EACjB,2BAA2B;EAC3B,oBAAoB;EACpB,gBAAgB;uCACqB,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA0mBlE,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA6BjC,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCrE,CAAC,SAAS,EAAE,CAAC;AACd,CAAC;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AACnF,MAAM,CAAC,MAAM,mCAAmC,GAAG,oBAAoB,CAAC,2BAA2B,CAAC,CAAC"}
+{"version":3,"file":"runtime-foundation.js","sourceRoot":"","sources":["../src/runtime-foundation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EACjC,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,iCAAiC,CAAC;AAEzC,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsa7C,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsGpD,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;CAyBpD,CAAC,SAAS,EAAE,CAAC;AAEd,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,iCAAiC,KAAK,2BAA2B,EAAE,CAAC;AAE7G,SAAS,oBAAoB,CAAC,gBAAwB;IACpD,OAAO,MAAM,CAAC,GAAG,CAAA;EACjB,2BAA2B;EAC3B,oBAAoB;EACpB,gBAAgB;uCACqB,IAAI,CAAC,SAAS,CAAC,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAw1BlE,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;2BAwBhC,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;0KACmG,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDrM,CAAC,SAAS,EAAE,CAAC;AACd,CAAC;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AACnF,MAAM,CAAC,MAAM,mCAAmC,GAAG,oBAAoB,CAAC,2BAA2B,CAAC,CAAC"}

package/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AA6eA,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CA04FvD,CAAC;AAEH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC3D;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,GAAE,qBAAqC,GAAG,MAAM,GAAG,IAAI,CAUzG"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAsgBA,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CA8/FvD,CAAC;AAEH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC3D;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,GAAE,qBAAqC,GAAG,MAAM,GAAG,IAAI,CAUzG"}