@benev/tact 0.4.0-6 → 0.4.0-8

package/README.md

@@ -2,19 +2,21 @@
 # 🎮 @benev/tact
 > *from keypress to couch co-op.*
 
-**tact is a user-input toolkit for web games.**  
-i made tact because i want to make indie web game development easier. user input seems like it should be easy, but doing it well is actually really complex. especially when you start thinking of multiplayer and multithreading. my goal with tact is to tame the complexity and give people something elegant and flexible that "just works".
+### tact is a user-input toolkit for web games.
 
 🌐 👉 ***https://tact.benev.gg/*** 👈 *try now*  
-
 🖱 keyboards, mice, gamepads.  
-🧩 expressive bindings json dsl.  
-🎨 bindings are user-customizable.  
-🫂 multiplayer and splitscreen capable.  
-🧬 binary for efficient workers and networking.  
-🎸 ready-to-rock drop-in user-interface.  
+🔥 powerful enough for multiplayer games, simple enough for any app.  
+🎸 users can customize keybinds with the ready-to-rock ui.  
+🧬 expressive bindings json dsl.  
+📡 binary streaming for multiplayer and multithreading.  
 ✍️ handcrafted by a human being.  
 
+user input isn't as simple as you'd think.  
+after many design iterations, tact has evolved into an elegant system that handles hard problems for you like customizability, multiplayer, and multithreading. i'm trying to give you the *"it just works"* experience.
+
+i care about the little things. all input types are boiled down to simple numbers, and packed up into efficient binary packets for streaming across networks and web workers. mouse movement precision and accuracy is holy, so there's careful design to make it resilient in the face of encoder/decoder sampling frequency mismatches. the bindings language is an infinitely capable recursive dsl so you can remap values from funky gamepads and make ridiculously complex logical hotkey combinations.
+
 
 
 ![](https://i.imgur.com/dCAlD14.png)
@@ -26,6 +28,7 @@ i made tact because i want to make indie web game development easier. user input
 <br/>
 
 ## 🎮 let's play.
+> *here's the fully-featured, batteries-included, ready-for-anything web game starter pack.*
 
 - 🍏 **install tact into your typescript project.**
     ```sh
@@ -41,8 +44,7 @@ i made tact because i want to make indie web game development easier. user input
       look: ["accumulate", "pointer.x"],
     })
     ```
-    - 💡 *bindings is a tiny json dsl. see [expression.ts](./s/lib/input/expression.ts).*
-- 🍏 **let's have two presets available to the user. one for gamepads.**
+- 🍏 **let's have two presets available to the user, with one for gamepads.**
     ```ts
     import {asPresets} from "@benev/tact"
 
@@ -55,7 +57,7 @@ i made tact because i want to make indie web game development easier. user input
       }},
     })
     ```
-- 🍏 **setup tact.**
+- ⚙️ **setup tact.**
     ```ts
     import {setupTact} from "@benev/tact"
 
@@ -64,15 +66,22 @@ i made tact because i want to make indie web game development easier. user input
     tact.gamepads("gamepad")
     tact.registerElements()
     ```
-    - 💡 *you can set `maxPlayers` to 1 for single player.*
+    - 💡 *you can set `{maxPlayers: 1}` for a single player game.*
+    - 💡 *you can pass `{namespace: "falrysk"}` if you need to run multiple games on one website.*
+    - 💡 *you can register elements manually like `customElements.define("tact-deck-falrysk", tact.elements.TactDeck)`.*
+    - 💡 *you can call `tact.dispose()` to release resources.*
 - 🍏 **encoding, decoding, and your game logic.**
     ```ts
+    import {Collector} from "@benev/tact"
+
+    const collector = new Collector(bindings)
+
     setInterval(() => {
-      const buffer = tact.deck.hub.encodeAll()
-      for (const {playerId, inputs} of tact.collector.decodeAll(buffer)) {
+      const buffer = tact.encodeAll()
+      for (const {playerId, inputs} of collector.decodeAll(buffer)) {
 
         // your game logic can read these handy input values.
-        inputs.jump.value // values are numbers 0  to 1.
+        inputs.jump.value // button-like values are numbers 0 to 1.
         inputs.jump.was // previous value (to detect up/down).
         inputs.jump.sum // sum of values reported since last frame.
 
@@ -81,19 +90,18 @@ i made tact because i want to make indie web game development easier. user input
       }
     }, 16.67)
     ```
-    - 💡 *maybe imagine streaming the buffers across the network to a remote collector.*
-    - 💡 *maybe imagine the tact deck on the clientside, and the collector on the serverside (or a web worker!).*
+    - 💡 *you could stream the buffers across the network to a remote collector, maybe with [renraku](https://github.com/e280/renraku).*
+    - 💡 *you could have the tact deck on the clientside, and the collector on the serverside (or a web worker!).*
 - 🍏 **put the `<tact-deck>` element in your html page.**
     ```html
     <tact-deck></tact-deck>
     ```
-    - 💡 *you also have each panel, `<tact-controllers>` and `<tact-customize>`.*
+    - 💡 *or just use the sub-panels directly, `<tact-controllers>` and `<tact-customize>`.*
     - 💡 *you can customize the colors with css.*
         ```html
         <style>
           html {
             --tact-prime: aqua;
-            --tact-bg: black;
           }
         </style>
         ```
@@ -104,15 +112,15 @@ i made tact because i want to make indie web game development easier. user input
 <br/>
 
 ## 🎮 get down to brass tacks.
-> *tact is flexible and composable for alternative use-cases.*
+> *for simpler apps, you can use tact's composable parts more directly.*
 
-- 🍏 **pov: your app isn't a game, no multiplayer, no gamepads.**  
+- ⚙️ **pov: your app isn't a game, no multiplayer, no gamepads.**  
     ```ts
-    import {setupTact, InputDecoder} from "@benev/tact"
+    import {setupTact, Decoder} from "@benev/tact"
 
     const tact = await setupTact({presets, maxPlayers: 1})
     const controller = tact.mouseKeyboard()
-    const decoder = new InputDecoder(bindings)
+    const decoder = new Decoder(bindings)
     tact.registerElements()
 
     setInterval(() => {
@@ -124,13 +132,13 @@ i made tact because i want to make indie web game development easier. user input
     }, 16.67)
     ```
     - 💡 *then the only ui you need is the `<tact-customize>` panel (also available as a sly view `CustomizeView`).*
-- 🍏 **pov: your app doesn't even want any ui, or persistence.**  
+- ⚙️ **pov: your app doesn't even want any ui, or persistence.**  
     ```ts
-    import {Controller, InputDecoder, KeyboardSource, PointerSource, Sources} from "@benev/tact"
+    import {Controller, Decoder, KeyboardSource, PointerSource, Sources} from "@benev/tact"
 
     const source = new Sources(new KeyboardSource(), new PointerSource())
     const controller = new Controller({bindings, source})
-    const decoder = new InputDecoder(bindings)
+    const decoder = new Decoder(bindings)
 
     setInterval(() => {
       const inputs = decoder.decode(controller.encode())
@@ -143,6 +151,67 @@ i made tact because i want to make indie web game development easier. user input
 
 
 
+<br/>
+
+## 🎮 bindings.
+> *bindings are a little json programming language.*
+
+- 🧬 **see [expression.ts](./s/lib/input/expression.ts) to get an idea of what's possible.**  
+- 🧬 **arbitrary nesting is valid.**
+    ```ts
+    asBindings("KeyW")
+
+    inputs.value // 1
+    ```
+    ```ts
+    asBindings({
+      actions: {
+        special: {
+          castMagicSpell: ["*", ["mod", "shift", "alt"], "KeyR"],
+        }
+      }
+    })
+
+    inputs.actions.special.castMagicSpell.value // 1
+    ```
+- 🧬 **you can differentiate taps versus holds on the same key.**
+    ```ts
+    asBindings({
+
+      // tapping E yoinks a weapon into your inventory.
+      grab: ["taps", 1, 250, "KeyE"],
+
+      // holding E equips the weapon as your primary.
+      equip: ["held", 250, "KeyE"],
+    })
+    ```
+- 🧬 **you can "accumulate" mouse inputs accurately,** to avoid losses in sampling frequency mismatches.
+    ```ts
+    asBindings({
+      lookX: ["accumulate", "pointer.x"],
+    })
+
+    inputs.lookX.sum // use sum instead of value, to ensure you don't lose any pointer movement.
+    ```
+- 🧬 **gamepads thumbstick inputs are best done with some math.**
+    ```ts
+    asBindings({
+      forward: ["*",
+
+        // user-customizable sensitivity, equivalent with pointer-pixels-per-second.
+        1234,
+
+        // delta time factor, to ensure sensitivity is framerate-independent.
+        ["dt"],
+
+        // remapping the ranges because gamepads are naughty and often have jiggly deadzones.
+        ["remap", -0.1, -0.9, 0, 1, "gamepad.axis.1"],
+      ],
+    })
+    ```
+
+
+
 <br/><br/>
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@benev/tact",
-	"version": "0.4.0-6",
+	"version": "0.4.0-8",
 	"description": "🎮 from keypress to couch co-op",
 	"license": "MIT",
 	"author": "Chase Moskal <chasemoskal@gmail.com>",
@@ -26,6 +26,7 @@
 		"lit": "^3.3.3"
 	},
 	"dependencies": {
+		"@awasm/noble": "^0.1.4",
 		"@benev/math": "0.4.0-9",
 		"@e280/kv": "^0.2.4",
 		"@e280/shiny": "^0.1.1",
@@ -35,7 +36,7 @@
 		"@e280/hottie": "^0.1.7",
 		"@e280/octo": "^0.1.7",
 		"@e280/science": "^0.1.14",
-		"@e280/scute": "^0.5.4",
+		"@e280/scute": "^0.5.5",
 		"http-server": "^14.1.1",
 		"npm-run-all": "^4.1.5",
 		"typescript": "^7.0.2"

package/s/lib/input/controller.ts

@@ -58,7 +58,10 @@ export class Controller<B extends Bindings = any> {
 	}
 
 	encode(time = performance.now()) {
-		return encodeIntents(this.#investigation.hash, [...this.evaluate(time)])
+		return encodeIntents(
+			this.#investigation.minihash,
+			[...this.evaluate(time)],
+		)
 	}
 
 	clear() {

package/s/lib/input/data/intent/decode.ts

@@ -8,7 +8,7 @@ export function decodeIntents(buffer: ArrayBuffer) {
 	const dv = new DataView(buffer)
 	let cursor = 0
 
-	const hash = dv.getUint32(cursor, endian)
+	const minihash = dv.getUint32(cursor, endian)
 	cursor += sizeHash
 
 	while (cursor < buffer.byteLength) {
@@ -21,6 +21,6 @@ export function decodeIntents(buffer: ArrayBuffer) {
 		intents.push({id, value})
 	}
 
-	return {hash, intents}
+	return {minihash, intents}
 }
 

package/s/lib/input/data/intent/encode.ts

@@ -3,13 +3,13 @@ import {Intent} from "./types.js"
 import {endian} from "../endian.js"
 import {sizeHash, sizeId, sizeIntent, sizeValue} from "./sizes.js"
 
-export function encodeIntents(hash: number, intents: Intent[]) {
+export function encodeIntents(minihash: number, intents: Intent[]) {
 	const byteCount = sizeHash + (intents.length * sizeIntent)
 	const buffer = new ArrayBuffer(byteCount)
 	const dv = new DataView(buffer)
 	let cursor = 0
 
-	dv.setUint32(cursor, hash, endian)
+	dv.setUint32(cursor, minihash, endian)
 	cursor += sizeHash
 
 	for (const intent of intents) {

package/s/lib/input/data/intent/minihash.ts

@@ -0,0 +1,5 @@
+
+export function minihash(hash: string) {
+	return Number.parseInt(hash.slice(0, 8), 16)
+}
+

package/s/lib/input/decoder.ts

@@ -3,7 +3,7 @@ import {Inputs, Bindings} from "./types.js"
 import {decodeIntents} from "./data/intent/decode.js"
 import {investigate} from "./investigate/investigate.js"
 
-export class InputDecoder<B extends Bindings> {
+export class Decoder<B extends Bindings> {
 	#investigation
 
 	constructor(bindings: B) {
@@ -25,7 +25,7 @@ export class InputDecoder<B extends Bindings> {
 		for (const buffer of buffers) {
 			const decoded = decodeIntents(buffer)
 
-			if (decoded.hash !== this.#investigation.hash)
+			if (decoded.minihash !== this.#investigation.minihash)
 				throw new Error("intent bindings hash mismatch")
 
 			for (const input of inputs)

package/s/lib/input/evaluate/context.ts

@@ -11,6 +11,10 @@ export class EvaluationContext {
 	previousValues = new Map<string, number>()
 
 	holding = new Map<object, {start: number}>()
-	tapping = new Map<object, {events: number[]}>()
+	tapping = new Map<object, {
+		wasDown: boolean
+		startedAt: number | null
+		count: number
+	}>()
 }
 

package/s/lib/input/evaluate/evaluate.ts

@@ -1,6 +1,6 @@
 
 import {remap} from "@benev/math"
-import {arraylimit, guarantee, isHappy, isNumber, isString} from "@e280/stz"
+import {guarantee, isHappy, isNumber, isString} from "@e280/stz"
 
 import {isDown} from "../utils/is-down.js"
 import {EvaluationContext} from "./context.js"
@@ -181,27 +181,40 @@ export function evaluate(
 
 		case "taps": {
 			const [, taps, ms, subexpression] = expression
-			const presses = e(subexpression)
+			const down = isDown(e(subexpression))
 			const now = context.clock.time
 
-			const tapped = guarantee(context.tapping, expression, () => ({
-				events: [] as number[],
+			const state = guarantee(context.tapping, expression, () => ({
+				wasDown: false,
+				startedAt: null as number | null,
+				count: 0,
 			}))
 
-			for (let i = 0; i < presses; i++)
-				tapped.events.push(now)
+			const pressed = down && !state.wasDown
+			const released = !down && state.wasDown
 
-			tapped.events = arraylimit(
-				tapped.events.filter(time => time >= now - ms),
-				128,
-			)
+			if (state.startedAt !== null && now - state.startedAt >= ms) {
+				state.startedAt = null
+				state.count = 0
+			}
+
+			let result = 0
 
-			if (tapped.events.length >= taps) {
-				tapped.events = []
-				return 1
+			if (pressed && state.startedAt === null)
+				state.startedAt = now
+
+			if (released && state.startedAt !== null) {
+				state.count++
+
+				if (state.count === taps) {
+					result = 1
+					state.count = 0
+					state.startedAt = null
+				}
 			}
 
-			return 0
+			state.wasDown = down
+			return result
 		}
 
 		case "mod": {

package/s/lib/input/investigate/hash-bindings.ts

@@ -1,6 +1,7 @@
 
-import {hash32} from "@e280/stz"
+import {hex} from "@e280/stz"
 import {Bindings} from "../types.js"
+import {hash} from "../../utils/hash.js"
 import {isExpression} from "./is-expression.js"
 
 export function hashBindings(bindings: Bindings) {
@@ -8,7 +9,7 @@ export function hashBindings(bindings: Bindings) {
 
 	function recurse(b: Bindings, path: string[]) {
 		if (isExpression(b)) {
-			paths.push(path.join("."))
+			paths.push(JSON.stringify(path))
 		}
 		else {
 			for (const [key, value] of Object.entries(b))
@@ -17,6 +18,7 @@ export function hashBindings(bindings: Bindings) {
 	}
 
 	recurse(bindings, ["b"])
-	return hash32(...paths)
+	paths.sort()
+	return hex(hash("tact/bindings/v1", ...paths).slice(16))
 }
 

package/s/lib/input/investigate/investigate.ts

@@ -5,31 +5,46 @@ import {Expression} from "../expression.js"
 import {hashBindings} from "./hash-bindings.js"
 import {isExpression} from "./is-expression.js"
 import {Bindings, Input, Inputs} from "../types.js"
+import {minihash} from "../data/intent/minihash.js"
 
 export function investigate<B extends Bindings>(bindings: B) {
 	const hash = hashBindings(bindings)
-	const inputList: Input[] = []
-	const rootList: Expression[] = []
 
-	function makeInputs(b: Bindings): unknown {
+	const leaves: {
+		path: string
+		input: Input
+		expression: Expression
+	}[] = []
+
+	function makeInputs(b: Bindings, path: string[]): unknown {
 		if (isExpression(b)) {
 			const input = makeInput()
-			inputList.push(input)
-			rootList.push(b)
+			leaves.push({
+				path: JSON.stringify(path),
+				input,
+				expression: b,
+			})
 			return input
 		}
 		else {
-			return obmap(b, makeInputs)
+			return obmap(b, (value, key) =>
+				makeInputs(value, [...path, key as string])
+			)
 		}
 	}
 
-	const inputs = makeInputs(bindings) as Inputs<B>
+	const inputs = makeInputs(bindings, ["b"]) as Inputs<B>
+
+	leaves.sort((a, b) =>
+		a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+	)
 
 	return {
 		hash,
+		minihash: minihash(hash),
 		inputs,
-		inputList,
-		rootList,
+		inputList: leaves.map(l => l.input),
+		rootList: leaves.map(l => l.expression),
 	}
 }
 

package/s/lib/input/test.ts

@@ -5,6 +5,7 @@ import {asBindings} from "./types.js"
 import {Controller} from "./controller.js"
 import {PlainSource} from "./sources/plain.js"
 import {quickbind} from "./testing/quickbind.js"
+import {isCompatible} from "./investigate/is-compatible.js"
 
 import parcel from "./data/test.js"
 
@@ -23,6 +24,16 @@ export default suite({
 		expect(inputs.was).is(0)
 	}),
 
+	"reordered bindings are equivalent": test(async() => {
+		const able = quickbind({alpha: "KeyA", bravo: "KeyB"})
+		const baker = quickbind({bravo: "KeyB", alpha: "KeyA"})
+		expect(isCompatible(able.bindings, baker.bindings)).is(true)
+		able.sample({code: "KeyA", value: 1})
+		const inputs = baker.decoder.decode(able.controller.encode())
+		expect(inputs.alpha.value).is(1)
+		expect(inputs.bravo.value).is(0)
+	}),
+
 	"update bindings": test(async() => {
 		const {sample, solve, controller} = quickbind("KeyA")
 
@@ -103,16 +114,28 @@ export default suite({
 		expect(inputs.sum).is(0)
 	}),
 
-	"double tap in one frame": test(async() => {
-		const {sample, solve} = quickbind(
-			["taps", 2, 300, ["down", "KeyE"]]
-		)
-
-		for (const value of [1, 0, 1, 0])
+	"single tap": test(async() => {
+		const {sample, solve} = quickbind(["taps", 1, 400, "KeyE"])
+		const hit = (time: number, value: number) => {
 			sample({code: "KeyE", value})
+			return solve(time).value
+		}
+		expect(hit(0, 0)).is(0)
+		expect(hit(100, 1)).is(0)
+		expect(hit(200, 0)).is(1)
+	}),
 
-		expect(solve(100).value).is(1)
-		expect(solve(200).value).is(0)
+	"double tap": test(async() => {
+		const {sample, solve} = quickbind(["taps", 2, 400, "KeyE"])
+		const hit = (time: number, value: number) => {
+			sample({code: "KeyE", value})
+			return solve(time).value
+		}
+		expect(hit(0, 0)).is(0)
+		expect(hit(100, 1)).is(0)
+		expect(hit(200, 0)).is(0)
+		expect(hit(300, 1)).is(0)
+		expect(hit(400, 0)).is(1)
 	}),
 
 	"held across empty frames": test(async() => {
@@ -136,30 +159,29 @@ export default suite({
 		expect(solve(900).value).is(1)
 	}),
 
-	"taps and holds coexist": test(async() => {
+	"taps vs held": test(async() => {
 		const {sample, solve} = quickbind({
-			tapper: ["taps", 1, 10, ["down", "KeyE"]],
-			holder: ["held", 10, "KeyE"],
+			tappy: ["taps", 1, 300, "KeyE"],
+			holdy: ["held", 300, "KeyE"],
 		})
-
-		solve(0)
-
-		sample({code: "KeyE", value: 1})
-		expect(solve(1).tapper.value).is(1)
-
-		sample({code: "KeyE", value: 0})
-		const released = solve(2)
-		expect(released.tapper.value).is(0)
-		expect(released.holder.value).is(0)
-
-		sample({code: "KeyE", value: 1})
-		const pressed = solve(3)
-		expect(pressed.tapper.value).is(1)
-		expect(pressed.holder.value).is(0)
-
-		const holding = solve(13)
-		expect(holding.tapper.value).is(0)
-		expect(holding.holder.value).is(1)
+		const hit = (time: number, value: number) => {
+			sample({code: "KeyE", value})
+			return solve(time)
+		}
+		const __up = (time: number) => hit(time, 0)
+		const DOWN = (time: number) => hit(time, 1)
+
+		expect(__up(1000).tappy.value).is(0)
+		expect(DOWN(1100).tappy.value).is(0)
+		expect(__up(1200).tappy.value).is(1)
+		expect(__up(1300).tappy.value).is(0)
+
+		expect(__up(2000).holdy.value).is(0)
+		expect(DOWN(2100).holdy.value).is(0)
+		expect(DOWN(2200).holdy.value).is(0)
+		expect(DOWN(2300).holdy.value).is(0)
+		expect(DOWN(2400).holdy.value).is(1)
+		expect(__up(2500).tappy.value).is(0) // FAILS
 	}),
 
 	"independent controller consumers": test(async() => {

package/s/lib/input/testing/quickbind.ts

@@ -1,5 +1,5 @@
 
-import {InputDecoder} from "../decoder.js"
+import {Decoder} from "../decoder.js"
 import {Controller} from "../controller.js"
 import {Bindings, Sample} from "../types.js"
 import {PlainSource} from "../sources/plain.js"
@@ -7,7 +7,7 @@ import {PlainSource} from "../sources/plain.js"
 export function quickbind<B extends Bindings>(b: B) {
 	const source = new PlainSource()
 	const controller = new Controller({source, bindings: b})
-	const decoder = new InputDecoder(controller.bindings)
+	const decoder = new Decoder(controller.bindings)
 	const {inputs} = decoder
 
 	const sample = (...samples: Sample[]) =>
@@ -16,6 +16,6 @@ export function quickbind<B extends Bindings>(b: B) {
 	const solve = (time?: number) =>
 		decoder.decode(controller.encode(time))
 
-	return {source, controller, decoder, sample, solve, inputs}
+	return {bindings: b, source, controller, decoder, sample, solve, inputs}
 }
 

package/s/lib/ui/deck/auto-gamepads.ts

@@ -21,6 +21,7 @@ export function autoGamepads(
 		const dispose = fn?.(controller, source)
 
 		return () => {
+			controller.dispose()
 			hub.remove(controller)
 			dispose?.()
 		}

package/s/lib/ui/deck/collector.ts

@@ -4,12 +4,12 @@ import {guarantee} from "@e280/stz"
 
 import {PlayerId} from "./types.js"
 import {Bindings} from "../../input/types.js"
-import {InputDecoder} from "../../input/decoder.js"
+import {Decoder} from "../../input/decoder.js"
 import {decodeParcels} from "../../input/data/parcel/decode.js"
 
 export class Collector<B extends Bindings> {
 	#bindings: B
-	#decoders = new RMap<PlayerId, InputDecoder<B>>()
+	#decoders = new RMap<PlayerId, Decoder<B>>()
 
 	constructor(bindings: B) {
 		this.#bindings = bindings
@@ -26,7 +26,7 @@ export class Collector<B extends Bindings> {
 		return guarantee(
 			this.#decoders,
 			playerId,
-			() => new InputDecoder(this.#bindings),
+			() => new Decoder(this.#bindings),
 		)
 	}
 

package/s/lib/ui/deck/hub.ts

@@ -5,18 +5,19 @@ import {got, IdCounter} from "@e280/stz"
 import {PlayerId} from "./types.js"
 import {Bindings} from "../../input/types.js"
 import {Controller} from "../../input/controller.js"
+import {minihash} from "../../input/data/intent/minihash.js"
 import {encodeParcels} from "../../input/data/parcel/encode.js"
 import {encodeIntents} from "../../input/data/intent/encode.js"
 import {hashBindings} from "../../input/investigate/hash-bindings.js"
 
 export class Hub<B extends Bindings = any> {
-	#hash
+	#minihash
 	#ids = new IdCounter()
 	#unassigned = new RSet<Controller<B>>()
 	#players = new RMap<PlayerId, {controllers: RSet<Controller<B>>}>()
 
 	constructor(readonly bindings: B) {
-		this.#hash = hashBindings(bindings)
+		this.#minihash = minihash(hashBindings(bindings))
 	}
 
 	get playerIds() {
@@ -86,7 +87,7 @@ export class Hub<B extends Bindings = any> {
 			.filter(([, value]) => value !== 0)
 			.map(([id, value]) => ({id, value}))
 
-		return encodeIntents(this.#hash, changedIntents)
+		return encodeIntents(this.#minihash, changedIntents)
 	}
 
 	encodeAll(time = performance.now()) {