@velarscript/web 0.27.4 → 0.28.1

package/dist/runtime-foundation.js

@@ -569,6 +569,7 @@ ${errorHostRuntime}
 const __velarRuntimeKey = Symbol.for(${JSON.stringify(VELAR_RUNTIME_REGISTRY_KEY)});
 const __velarFoundationReflectApply = Object.getOwnPropertyDescriptor(Reflect, "apply")?.value;
 const __velarFoundationQueueMicrotask = globalThis.queueMicrotask;
+const __velarFoundationSetTimeout = globalThis.setTimeout;
 const __velarFoundationDate = globalThis.Date;
 const __velarFoundationDateNow = typeof __velarFoundationDate === "function"
   ? Object.getOwnPropertyDescriptor(__velarFoundationDate, "now")?.value
@@ -680,12 +681,120 @@ function __velarNextObserverSequence() {
   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;
+// D114 W/A1, as narrowed by W2: the identity a flush stamps its run counts
+// with, and the budget those runs spend. They belong to one host *task* -- but
+// the window follows work an observer started, and nothing else.
+//
+// A cycle that crosses a microtask boundary -- 'watch x: detach step()', where
+// 'step' awaits an already-resolved Promise and then writes 'x' -- is a fresh
+// flush every round, so a budget that reset per flush never saw it: two
+// observer runs, well inside 100,000, forever. Flushes chained through
+// microtasks therefore share one token, one budget and one leaders list, and
+// the macrotask sentinel below closes the window. Work that resumes after a
+// timer, an event or network I/O is a new task and opens a fresh window, which
+// is what keeps an animation that writes state every frame from being stopped.
+//
+// W2: a flush continues the open window only once an observer run inside it has
+// started asynchronous work -- a 'detach' statement, or an 'action' call, made
+// while an observer was running. Those are the two ways a synchronous observer
+// body reaches a later microtask, so they are the only ways the ring above can
+// be closed; a chain of flushes with none of them in it has no cycle to find. A
+// bulk import loop that writes a progress counter and awaits promise-only work
+// per row runs millions of observers in one uninterrupted task and is not a
+// runaway, so each of its flushes gets the fresh budget it had before W. The
+// sentinel still closes every window at the task boundary, so the animation
+// case is protected either way.
+//
+// The overrun's carried token is the same rule seen from one flush earlier: an
+// overrun schedules its continuation as a microtask, so that continuation is
+// this same task and continues these same counts by construction. It carries
+// them whether or not an observer started anything, because the continuation is
+// the overrun's own unfinished work rather than a new write.
+const __velarFlushBudgetPerTask = 100000;
+let __velarFlushToken = null;
+let __velarFlushBudget = 0;
+// One-shot, consumed by the next settle: the flush an overrun scheduled
+// continues the window it was scheduled from, whatever that window recorded.
+let __velarFlushCarried = false;
+// One sentinel is enough for a window: the first one to fire closes it, and
+// arming a second on every flush would leave a timer per flush behind.
+let __velarTaskSentinelArmed = false;
+
+// The two facts W2 needs live on one global slot, for the same reason the
+// observer sequence above does: every emitted module carries its own copy of
+// this runtime, and the two ends of the question are in different copies. The
+// settle that asks it belongs to whichever copy created the registry -- in an
+// application that imports velar/app, that is velar/app's -- while the places
+// that answer it, a 'detach' statement's detached-task helper and an action's
+// run, are emitted into the application module. Two module-scope variables
+// would never meet.
+//
+// Slot 0 is how deep the settle currently is inside 'observer.run()'. It is a
+// depth rather than a flag because an observer created by a running one runs
+// nested. '__velarRuntime.activeObserver' cannot stand in for it: a watch body
+// runs untracked, precisely so its own reads do not become dependencies of the
+// watched expression, so the active observer is null exactly where the 'detach'
+// that closes a cycle is written.
+//
+// Slot 1 is the fact recorded on the open window: an observer run in it started
+// asynchronous work.
+const __velarAsyncWorkKey = Symbol.for("velar.web.observer.asyncwork.v1");
+const __velarAsyncWorkCell = (() => {
+  const descriptor = __velarGraphOwnDescriptor(globalThis, __velarAsyncWorkKey);
+  if (descriptor) {
+    if (!("value" in descriptor) || descriptor.enumerable || descriptor.configurable || descriptor.writable
+      || !__velarGraphIsList(descriptor.value)) {
+      throw new TypeError("VelarScript Web observer async-work ownership is invalid");
+    }
+    return descriptor.value;
+  }
+  const cell = [0, false];
+  __velarGraphDefine(globalThis, __velarAsyncWorkKey, {
+    value: cell,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+  return cell;
+})();
+
+// What the two compiler-owned lowering points call: the detached-task helper a
+// 'detach' statement lowers to, where a detached Promise enters the runtime,
+// and an action's run, where an action call does. Outside an observer run there
+// is nothing to record -- an action a handler or '@main' starts is the host
+// task's own work, not a ring an observer closed -- so the same unconditional
+// call is correct at both sites.
+function __velarNoteAsyncWork() {
+  if (__velarAsyncWorkCell[0] > 0) __velarAsyncWorkCell[1] = true;
+  return null;
+}
+
+function __velarCloseTaskWindow() {
+  __velarTaskSentinelArmed = false;
+  __velarFlushToken = null;
+  __velarAsyncWorkCell[1] = false;
+  return null;
+}
+
+// The macrotask boundary the run-count window ends at. 'setTimeout' is the one
+// scheduling operation every host this runtime supports publishes -- page,
+// worker, and the Node process a 'velar test' run drives the emitted runtime
+// in -- and it is captured at module initialization like every other ambient
+// operation here. A host that publishes none is not left without a gate: the
+// window then closes as soon as the flush chain comes to rest, which is the
+// per-flush budget this runtime had before, so the synchronous cycles stay
+// covered and only the asynchronous one goes back to being invisible.
+function __velarArmTaskSentinel() {
+  if (__velarTaskSentinelArmed) return true;
+  if (typeof __velarFoundationSetTimeout !== "function" || typeof __velarFoundationReflectApply !== "function") return false;
+  __velarTaskSentinelArmed = true;
+  try { __velarFoundationReflectApply(__velarFoundationSetTimeout, globalThis, [__velarCloseTaskWindow, 0]); }
+  catch { __velarTaskSentinelArmed = false; return false; }
+  return true;
+}
 
-// 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 three observers that have run most in the task window 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.
@@ -741,7 +850,7 @@ function __velarFlushRunaway(stalled, token) {
     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
+    detail += (detail === "" ? "Ran most in this task: " : ", ") + named
       + " (" + observer.flushRuns + (observer.flushRuns === 1 ? " run)" : " runs)");
     if (component === "" && typeof observer.component === "string") component = observer.component;
   }
@@ -794,12 +903,17 @@ function __velarFlushOverflow(token) {
     requeued = true;
   }
   const runaway = __velarFlushRunaway(stalled, token);
-  __velarRuntime.report(new RangeError("Reactive updates cannot run more than 100000 observers in one flush"),
+  // The window keeps its token and its run counts -- the requeued flush is one
+  // more flush of the same task, and the pool of observers it has not reached
+  // yet only shrinks -- but the budget is granted again. Without that, the
+  // exhausted count would trip the very next flush of the same task, and the
+  // observers stopped for it would be whatever was queued at that moment: the
+  // innocent ones this overrun just put back, or an unrelated later write.
+  __velarFlushBudget = __velarFlushBudgetPerTask;
+  __velarFlushCarried = requeued;
+  __velarRuntime.report(new RangeError("Reactive updates cannot run more than " + __velarFlushBudgetPerTask + " observers in one task"),
     { phase: "update", detail: runaway.detail, component: runaway.component, unhandled: true });
-  if (requeued) {
-    __velarOverflowToken = token;
-    __velarScheduleFlush();
-  }
+  if (requeued) __velarScheduleFlush();
 }
 
 // The one entry point: the microtask __velarScheduleFlush enqueues, and the
@@ -807,8 +921,18 @@ function __velarFlushOverflow(token) {
 // 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.
+//
+// D114 W/A1: it is also where the task window is closed or handed on. Both
+// entries pass through here, including tick()'s drain, so the sentinel is armed
+// once per window however the flush was reached, and a host without a timer
+// falls back to closing the window here, one flush at a time.
 function __velarFlush() {
-  __velarFlushSettle();
+  try { __velarFlushSettle(); }
+  // Without a timer the window closes as soon as the chain comes to rest,
+  // which is the per-flush budget this runtime had before -- except that a
+  // flush already scheduled keeps it open, so an overrun's carried counts and
+  // the queues a settle could not finish reach the flush that continues them.
+  finally { if (!__velarArmTaskSentinel() && !__velarRuntime.flushPending) __velarCloseTaskWindow(); }
 }
 
 // Glitch-free order: every derived value and every watch settles to a fixed
@@ -828,25 +952,42 @@ function __velarFlush() {
 // 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.
+//
+// D114 W/A1, narrowed by W2: a flush that starts while the task window is still
+// open continues it -- the same token, so flushRuns keeps accumulating on every
+// observer, the same leaders, and the same remaining budget -- but only when an
+// observer run in that window started asynchronous work, or when the overrun
+// itself scheduled this flush. Every other flush opens a new window, which is
+// the per-flush budget this runtime had before W.
 function __velarFlushSettle() {
   __velarRuntime.flushPending = false;
-  const token = __velarOverflowToken === null ? {} : __velarOverflowToken;
-  __velarOverflowToken = null;
-  __velarFlushLeaders.length = 0;
-  let budget = 100000;
+  const carried = __velarFlushCarried;
+  __velarFlushCarried = false;
+  if (__velarFlushToken === null || !(carried || __velarAsyncWorkCell[1])) {
+    __velarFlushToken = {};
+    __velarFlushBudget = __velarFlushBudgetPerTask;
+    __velarFlushLeaders.length = 0;
+    __velarAsyncWorkCell[1] = false;
+  }
+  const token = __velarFlushToken;
   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();
+    // The span the two lowering points ask about. It is the run itself rather
+    // than the whole settle: work started by the flush's own bookkeeping is
+    // not an observer's, and a nested observer created by a running one is.
+    __velarAsyncWorkCell[0] += 1;
+    try { observer.run(); }
+    finally { __velarAsyncWorkCell[0] -= 1; }
   };
   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; }
+        if ((__velarFlushBudget -= 1) < 0) { __velarFlushOverflow(token); return; }
         step(observer);
         ran = true;
       }
@@ -860,7 +1001,7 @@ function __velarFlushSettle() {
         // 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; }
+        if ((__velarFlushBudget -= 1) < 0) { __velarFlushOverflow(token); return; }
         step(observer);
         ran = true;
       }
@@ -868,7 +1009,7 @@ function __velarFlushSettle() {
     }
     for (const observer of __velarGraphSetItems(__velarRuntime.domQueue)) {
       if (observer.mode === "computed") break;
-      if ((budget -= 1) < 0) { __velarFlushOverflow(token); return; }
+      if ((__velarFlushBudget -= 1) < 0) { __velarFlushOverflow(token); return; }
       step(observer);
     }
   }

package/dist/runtime-foundation.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-foundation.js","sourceRoot":"","sources":["../src/runtime-foundation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"runtime-foundation.js","sourceRoot":"","sources":["../src/runtime-foundation.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velarscript/web",
-  "version": "0.27.4",
+  "version": "0.28.1",
   "description": "The official VelarScript Web framework contract and browser runtime.",
   "license": "Apache-2.0",
   "type": "module",
@@ -33,7 +33,7 @@
     }
   },
   "dependencies": {
-    "@velarscript/compiler": "0.27.4"
+    "@velarscript/compiler": "0.28.1"
   },
   "exports": {
     ".": {