@patterkit/runtime 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -33,6 +33,42 @@ version number always means the same runtime behaviour. This package is versione
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-09-01
+
+### Changed
+
+- **`rngState` is now written UNSIGNED in a save.** It was accumulated with
+  `| 0`, so more than half of all saves carried a negative number where the
+  schema says uint32. The draws were unaffected (signed and unsigned
+  accumulation produce bit-identical draws), but the native ports could not read
+  those saves back: Unity threw, and C++ read them through undefined behaviour.
+
+  Old saves still load here, because restore already coerced, and the native
+  ports now coerce too. No gameplay changes.
+
+- **Flags compare as a SET.** `==` and `!=` on a flags value now ignore order.
+  They are compared as multisets, so a duplicated flag still counts. A flags
+  value IS a set, and its stored order was an artefact of the order somebody
+  happened to add things in: `set_flags(@f, +red)` then `+blue` compared UNEQUAL
+  to the same two flags added the other way round. An expression that relied on
+  that will change answer.
+
+- The PRNG is now `@wildwinter/expr`'s `makePrng` rather than a copy inline here.
+  Same algorithm, same draws; mulberry32 existed thirteen times across the two
+  product families and is a fixed published algorithm neither owns.
+
+
+## [0.7.1] - 2026-08-30
+
+### Fixed
+
+- **A flow you forgot to announce still shows up in Patterpad's debug link.** `flowOpened` was the
+  host's job and nothing could check it, so a game that opened a flow and did not announce it left
+  the editor's follow list short - and the omission outlived a reconnect, because the link's hello
+  carries that list. A flow now announces itself the first time it is observed; `flowOpened` remains
+  worth calling for a flow that exists before it says anything. Reported from the Storylet Studio
+  side, 2026-08-29. (Same fix in all four runtimes.)
+
 ## [0.7.0] - 2026-08-29
 
 ### Changed

package/dist/index.cjs

@@ -647,7 +647,7 @@ var Flow = class {
   constructor(id, host, seed) {
     this.id = id;
     this.host = host;
-    this.rngState = seed >>> 0;
+    this.rngState = (0, import_expr.toUint32)(seed);
     this.local = this.freshLocal();
     const scopes = { ...host.shared.toEvalContext().scopes };
     scopes["patter"] = this.patterResolver;
@@ -945,7 +945,7 @@ var Flow = class {
   }
   /** @internal Restore this flow from a snapshot. */
   restore(snap) {
-    this.rngState = snap.rngState >>> 0;
+    this.rngState = (0, import_expr.toUint32)(snap.rngState);
     this.visitCounts = new Map(Object.entries(snap.visits ?? {}));
     const c = snap.cursor;
     this.started = true;
@@ -1260,14 +1260,19 @@ var Flow = class {
     this.visitCounts.set(id, (this.visitCounts.get(id) ?? 0) + 1);
     this.host.sharedVisits.set(id, (this.host.sharedVisits.get(id) ?? 0) + 1);
   }
-  /** Next float in [0, 1): the shared custom PRNG, or this flow's serialisable mulberry32. */
+  /** Next float in [0, 1): the shared custom PRNG, or this flow's serialisable mulberry32.
+   *
+   *  The mixing is @wildwinter/expr's makePrng, not a copy inline here. It is a
+   *  fixed published algorithm that both product families need and neither
+   *  owns, and it existed thirteen times across the two of them. `rngState` is
+   *  still the serialisable position, so saves are unaffected: a generator is
+   *  made from it, drawn once, and the new state written back. */
   rng = () => {
     if (this.host.customRng) return this.host.customRng();
-    const a = this.rngState + 1831565813 | 0;
-    this.rngState = a;
-    let t = Math.imul(a ^ a >>> 15, 1 | a);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    const prng = (0, import_expr.makePrng)(this.rngState);
+    const draw = prng.next();
+    this.rngState = prng.state();
+    return draw;
   };
   // -- Strings / beats ------------------------------------------------------
   beatResult(beat) {