@benev/tact 0.4.0-7 → 0.4.0-8

package/README.md

@@ -116,11 +116,11 @@ i care about the little things. all input types are boiled down to simple number
 
 - ⚙️ **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(() => {
@@ -134,11 +134,11 @@ i care about the little things. all input types are boiled down to simple number
     - 💡 *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.**  
     ```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())

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@benev/tact",
-	"version": "0.4.0-7",
+	"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/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")
 

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/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()) {

package/s/lib/utils/hash.ts

@@ -0,0 +1,47 @@
+
+import {blake3} from "@awasm/noble/js.js"
+import {dataViewFrom, txt} from "@e280/stz"
+
+const endian = false
+enum EntropyType {String, Number, Bytes}
+
+export function hash(...entropy: (string | number | Uint8Array)[]) {
+	if (entropy.length === 0)
+		throw new RangeError("hash requires entropy")
+
+	const hasher = blake3.create()
+	const typeTag = new Uint8Array(1)
+	const lengthTag = new Uint8Array(4)
+	const lengthDataview = dataViewFrom(lengthTag)
+
+	for (const part of entropy) {
+		if (typeof part === "string") {
+			const bytes = txt.toBytes(part)
+			typeTag[0] = EntropyType.String
+			lengthDataview.setUint32(0, bytes.byteLength, endian)
+			hasher.update(typeTag)
+			hasher.update(lengthTag)
+			hasher.update(bytes)
+		}
+		else if (typeof part === "number") {
+			const bytes = new Uint8Array(8)
+			dataViewFrom(bytes).setFloat64(0, part, endian)
+			typeTag[0] = EntropyType.Number
+			lengthDataview.setUint32(0, bytes.byteLength, endian)
+			hasher.update(typeTag)
+			hasher.update(lengthTag)
+			hasher.update(bytes)
+		}
+		else if (part instanceof Uint8Array) {
+			typeTag[0] = EntropyType.Bytes
+			lengthDataview.setUint32(0, part.byteLength, endian)
+			hasher.update(typeTag)
+			hasher.update(lengthTag)
+			hasher.update(part)
+		}
+		else throw new Error("unknown part type")
+	}
+
+	return hasher.digest() as Uint8Array
+}
+