typebulb 0.58.0 → 0.58.2

package/dist/format/runtimeState.d.ts

@@ -8,11 +8,13 @@
  *   init({ applyData, applyInsight, send })
  *     applyData(chunks)   -> put the chunks in this host's data global
  *     applyInsight(json)  -> put the serialized insight in this host's insight global
- *     send(pair)          -> hand { data?, insight? } to this host's transport; resolve the
- *                            shareable URL, or undefined when there is none. Must never reject:
- *                            every failure reads to a bulb as "no link".
+ *     send(pair)          -> hand { data?, insight? } to this host's transport; resolve once the
+ *                            write has landed. Must never reject: a transport failure costs the
+ *                            fragment, never the swap.
  *
- *   setData(chunks) / setInsight(value) -> the two tb.* writers, resolving send's URL
+ *   setData(chunks) / setInsight(value) -> the two tb.* writers, resolving once the address bar
+ *                            reflects the write. Neither hands back a link: the fragment is
+ *                            already in the URL, which a bulb reads with tb.url() like any other.
  *   seed(pair)  -> apply and record what a decoded `#tb=` fragment carried, without sending it back
  *   pair()      -> the wire pair, for a host that files it (the CLI modal's Save). Empty when
  *                  nothing has been set, which is also how a host asks whether anything has.
@@ -24,10 +26,9 @@
  * which stays exact for a null insight and needs no companion flag.
  *
  * Coalescing keys on whether the in-flight write has read the pair yet, not on whether one is
- * outstanding. Writes landing before that ride it and share its URL, one round trip for the pair;
- * a write landing after it queues one re-send, because the write on the wire carries a state the
- * page has moved past. Answering it with that URL would address a run the page no longer shows,
- * and skipping the re-send would leave the address bar doing so (Invariant 6).
+ * outstanding. Writes landing before that ride it, one round trip for the pair; a write landing
+ * after it queues one re-send, because the write on the wire carries a state the page has moved
+ * past, and skipping the re-send would leave the address bar addressing it (Invariant 6).
  */
 export declare const runtimeStateEngine = "(function () {\n  var W = window;\n  var rtData, rtInsight, rtHasInsight = false;\n  var applyData, applyInsight, send;\n  var pending = null, sent = false, queued = null;\n\n  var pair = function () {\n    var p = {};\n    if (rtData !== undefined) p.data = rtData;\n    if (rtHasInsight) p.insight = rtInsight;\n    return p;\n  };\n\n  var start = function () {\n    sent = false;\n    return Promise.resolve()\n      .then(function () { sent = true; return send(pair()); })\n      .catch(function () { return undefined; })\n      .finally(function () { pending = null; });\n  };\n  var publish = function () {\n    if (!pending) { pending = start(); return pending; }\n    if (!sent) return pending;\n    if (!queued) queued = pending.then(function () { queued = null; return publish(); });\n    return queued;\n  };\n\n  W.__tbState = {\n    init: function (o) { applyData = o.applyData; applyInsight = o.applyInsight; send = o.send; },\n    pair: pair,\n    // Applied but not sent: the fragment already holds this, so sending it back would re-encode\n    // the state the page just booted from.\n    seed: function (p) {\n      if (p.data !== undefined) { rtData = p.data; applyData(p.data); }\n      if ('insight' in p) { rtInsight = p.insight; rtHasInsight = true; applyInsight(JSON.stringify(p.insight, null, 2)); }\n    },\n    // The globals move before the round trip, so a synchronous tb.data() right after the await is\n    // never stale.\n    setData: function (chunks) {\n      var arr = Array.isArray(chunks) ? chunks : [chunks];\n      rtData = arr;\n      applyData(arr);\n      return publish();\n    },\n    setInsight: function (value) {\n      // Serialize before recording: a value JSON.stringify rejects (a cycle, a BigInt) must leave\n      // the slot untouched, or every later setter carries a pair that can never be encoded or sent.\n      var json = JSON.stringify(value, null, 2);\n      rtInsight = value;\n      rtHasInsight = true;\n      applyInsight(json);\n      return publish();\n    }\n  };\n})();";
 //# sourceMappingURL=runtimeState.d.ts.map

package/dist/format/runtimeState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeState.d.ts","sourceRoot":"","sources":["../../format/src/runtimeState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,kBAAkB,4/DAsDzB,CAAA"}
+{"version":3,"file":"runtimeState.d.ts","sourceRoot":"","sources":["../../format/src/runtimeState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,kBAAkB,4/DAsDzB,CAAA"}

package/dist/format/runtimeState.js

@@ -8,11 +8,13 @@
  *   init({ applyData, applyInsight, send })
  *     applyData(chunks)   -> put the chunks in this host's data global
  *     applyInsight(json)  -> put the serialized insight in this host's insight global
- *     send(pair)          -> hand { data?, insight? } to this host's transport; resolve the
- *                            shareable URL, or undefined when there is none. Must never reject:
- *                            every failure reads to a bulb as "no link".
+ *     send(pair)          -> hand { data?, insight? } to this host's transport; resolve once the
+ *                            write has landed. Must never reject: a transport failure costs the
+ *                            fragment, never the swap.
  *
- *   setData(chunks) / setInsight(value) -> the two tb.* writers, resolving send's URL
+ *   setData(chunks) / setInsight(value) -> the two tb.* writers, resolving once the address bar
+ *                            reflects the write. Neither hands back a link: the fragment is
+ *                            already in the URL, which a bulb reads with tb.url() like any other.
  *   seed(pair)  -> apply and record what a decoded `#tb=` fragment carried, without sending it back
  *   pair()      -> the wire pair, for a host that files it (the CLI modal's Save). Empty when
  *                  nothing has been set, which is also how a host asks whether anything has.
@@ -24,64 +26,63 @@
  * which stays exact for a null insight and needs no companion flag.
  *
  * Coalescing keys on whether the in-flight write has read the pair yet, not on whether one is
- * outstanding. Writes landing before that ride it and share its URL, one round trip for the pair;
- * a write landing after it queues one re-send, because the write on the wire carries a state the
- * page has moved past. Answering it with that URL would address a run the page no longer shows,
- * and skipping the re-send would leave the address bar doing so (Invariant 6).
+ * outstanding. Writes landing before that ride it, one round trip for the pair; a write landing
+ * after it queues one re-send, because the write on the wire carries a state the page has moved
+ * past, and skipping the re-send would leave the address bar addressing it (Invariant 6).
  */
-export const runtimeStateEngine = `(function () {
-  var W = window;
-  var rtData, rtInsight, rtHasInsight = false;
-  var applyData, applyInsight, send;
-  var pending = null, sent = false, queued = null;
-
-  var pair = function () {
-    var p = {};
-    if (rtData !== undefined) p.data = rtData;
-    if (rtHasInsight) p.insight = rtInsight;
-    return p;
-  };
-
-  var start = function () {
-    sent = false;
-    return Promise.resolve()
-      .then(function () { sent = true; return send(pair()); })
-      .catch(function () { return undefined; })
-      .finally(function () { pending = null; });
-  };
-  var publish = function () {
-    if (!pending) { pending = start(); return pending; }
-    if (!sent) return pending;
-    if (!queued) queued = pending.then(function () { queued = null; return publish(); });
-    return queued;
-  };
-
-  W.__tbState = {
-    init: function (o) { applyData = o.applyData; applyInsight = o.applyInsight; send = o.send; },
-    pair: pair,
-    // Applied but not sent: the fragment already holds this, so sending it back would re-encode
-    // the state the page just booted from.
-    seed: function (p) {
-      if (p.data !== undefined) { rtData = p.data; applyData(p.data); }
-      if ('insight' in p) { rtInsight = p.insight; rtHasInsight = true; applyInsight(JSON.stringify(p.insight, null, 2)); }
-    },
-    // The globals move before the round trip, so a synchronous tb.data() right after the await is
-    // never stale.
-    setData: function (chunks) {
-      var arr = Array.isArray(chunks) ? chunks : [chunks];
-      rtData = arr;
-      applyData(arr);
-      return publish();
-    },
-    setInsight: function (value) {
-      // Serialize before recording: a value JSON.stringify rejects (a cycle, a BigInt) must leave
-      // the slot untouched, or every later setter carries a pair that can never be encoded or sent.
-      var json = JSON.stringify(value, null, 2);
-      rtInsight = value;
-      rtHasInsight = true;
-      applyInsight(json);
-      return publish();
-    }
-  };
+export const runtimeStateEngine = `(function () {
+  var W = window;
+  var rtData, rtInsight, rtHasInsight = false;
+  var applyData, applyInsight, send;
+  var pending = null, sent = false, queued = null;
+
+  var pair = function () {
+    var p = {};
+    if (rtData !== undefined) p.data = rtData;
+    if (rtHasInsight) p.insight = rtInsight;
+    return p;
+  };
+
+  var start = function () {
+    sent = false;
+    return Promise.resolve()
+      .then(function () { sent = true; return send(pair()); })
+      .catch(function () { return undefined; })
+      .finally(function () { pending = null; });
+  };
+  var publish = function () {
+    if (!pending) { pending = start(); return pending; }
+    if (!sent) return pending;
+    if (!queued) queued = pending.then(function () { queued = null; return publish(); });
+    return queued;
+  };
+
+  W.__tbState = {
+    init: function (o) { applyData = o.applyData; applyInsight = o.applyInsight; send = o.send; },
+    pair: pair,
+    // Applied but not sent: the fragment already holds this, so sending it back would re-encode
+    // the state the page just booted from.
+    seed: function (p) {
+      if (p.data !== undefined) { rtData = p.data; applyData(p.data); }
+      if ('insight' in p) { rtInsight = p.insight; rtHasInsight = true; applyInsight(JSON.stringify(p.insight, null, 2)); }
+    },
+    // The globals move before the round trip, so a synchronous tb.data() right after the await is
+    // never stale.
+    setData: function (chunks) {
+      var arr = Array.isArray(chunks) ? chunks : [chunks];
+      rtData = arr;
+      applyData(arr);
+      return publish();
+    },
+    setInsight: function (value) {
+      // Serialize before recording: a value JSON.stringify rejects (a cycle, a BigInt) must leave
+      // the slot untouched, or every later setter carries a pair that can never be encoded or sent.
+      var json = JSON.stringify(value, null, 2);
+      rtInsight = value;
+      rtHasInsight = true;
+      applyInsight(json);
+      return publish();
+    }
+  };
 })();`;
 //# sourceMappingURL=runtimeState.js.map

package/dist/format/runtimeState.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeState.js","sourceRoot":"","sources":["../../format/src/runtimeState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsD5B,CAAA"}
+{"version":3,"file":"runtimeState.js","sourceRoot":"","sources":["../../format/src/runtimeState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsD5B,CAAA"}