@benev/archimedes 0.1.0-1

package/s/_archive/eureka/testing/situations/integration.ts

@@ -0,0 +1,45 @@
+
+import {setupEureka} from "../../eureka.js"
+import {EurekaContext} from "../../integration/context.js"
+
+export class DemoContext extends EurekaContext {}
+
+export type DemoComponents = {
+	health: number
+	bleeding: number
+	mana: number
+	manaRegen: number
+}
+
+export function setupEurekaDemo() {
+	const eureka = setupEureka<DemoContext, DemoComponents>()
+	const context = new DemoContext()
+	const world = eureka.world(context, [
+
+		eureka.system("mortality")
+			.select("health").andMaybe("bleeding")
+			.fn((entities, world) => {
+				for (const {id, components} of entities) {
+
+					// process bleeding
+					if (components.bleeding)
+						components.health -= components.bleeding
+
+					// process death
+					if (components.health <= 0)
+						world.delete(id)
+				}
+			}),
+
+		eureka.system("wizardry")
+			.select("mana").andMaybe("manaRegen")
+			.fn((entities, _world) => {
+				for (const {components} of entities)
+					if (components.manaRegen)
+						components.mana += components.manaRegen
+			}),
+
+	])
+	return {context, world}
+}
+

package/s/_archive/index.ts

@@ -0,0 +1,6 @@
+
+export * from "./core/contact/codecs.i.js"
+export * from "./core/contact/contact.js"
+export * from "./core/contact/types.js"
+export * from "./core/contact/wiring.i.js"
+

package/s/_archive/session/client.ts

@@ -0,0 +1,56 @@
+
+import {Seat} from "./parts/seat.js"
+import {Spoke} from "./parts/spoke.js"
+import {MetaApi} from "./meta/types.js"
+import {Liaison} from "../core/liaison.js"
+import {FiberRpc} from "./parts/fiber-rpc.js"
+import {Simulator} from "../core/simulator.js"
+import {Speculator} from "../core/speculator.js"
+import {makeMetaClientApi} from "./meta/meta-client.js"
+import {InferSimulatorSchema, Telegram} from "../core/types.js"
+
+export class SessionClient<xSimulator extends Simulator> {
+	static async make<xSimulator extends Simulator>(options: {
+			hz: number
+			spoke: Spoke
+			pastSimulator: xSimulator
+			futureSimulator: xSimulator
+		}) {
+
+		const meta = new FiberRpc<MetaApi["host"]>(
+			options.spoke.fibers.sub.meta,
+			makeMetaClientApi(),
+		).remote as MetaApi["host"]
+
+		const {hostAuthorId, clientAuthorId} = await meta.hello()
+		const liaison = new Liaison<Telegram<any>>(hostAuthorId, options.spoke.fibers.sub.primary)
+		const seat = new Seat(options.spoke, liaison)
+
+		const speculator = new Speculator<InferSimulatorSchema<xSimulator>>(
+			clientAuthorId,
+			liaison,
+			options.pastSimulator,
+			options.futureSimulator,
+			options.hz,
+		)
+
+		return new this<xSimulator>(
+			seat,
+			options.pastSimulator,
+			options.futureSimulator,
+			speculator,
+		)
+	}
+
+	constructor(
+		public seat: Seat,
+		public pastSimulator: xSimulator,
+		public futureSimulator: xSimulator,
+		public speculator: Speculator<InferSimulatorSchema<xSimulator>>,
+	) {}
+
+	disconnect() {
+		this.seat.disconnect()
+	}
+}
+

package/s/_archive/session/host.ts

@@ -0,0 +1,71 @@
+
+import {MapG} from "@e280/stz"
+
+import {Hub} from "./parts/hub.js"
+import {Seat} from "./parts/seat.js"
+import {MetaApi} from "./meta/types.js"
+import {HostOn} from "./parts/host-on.js"
+import {Liaison} from "../core/liaison.js"
+import {FiberRpc} from "./parts/fiber-rpc.js"
+import {Authority} from "../core/authority.js"
+import {Simulator} from "../core/simulator.js"
+import {makeMetaHostApi} from "./meta/meta-host.js"
+import {AuthorId, InferSimulatorSchema, Telegram} from "../core/types.js"
+
+export class SessionHost<xSimulator extends Simulator> {
+	authority: Authority<InferSimulatorSchema<xSimulator>>
+	seats = new MapG<AuthorId, Seat>()
+	on = new HostOn()
+
+	#cleanup = () => {}
+
+	constructor(
+			public hub: Hub,
+			public simulator: xSimulator,
+		) {
+
+		const authority = new Authority(simulator)
+		this.authority = authority
+
+		this.#cleanup = hub.onSpoke(spoke => {
+			const authorId = authority.idCounter.next()
+
+			const liaison = new Liaison<Telegram<any>>(authorId, spoke.fibers.sub.primary)
+			authority.liaisons.add(liaison)
+			liaison.send(authority.getStateTelegram())
+
+			new FiberRpc<MetaApi["host"]>(
+				spoke.fibers.sub.meta,
+				makeMetaHostApi({authority, liaison}),
+			).remote as MetaApi["client"]
+
+			const seat = new Seat(spoke, liaison)
+			this.seats.set(authorId, seat)
+			this.on.seated.pub(seat)
+
+			return () => {
+				authority.liaisons.delete(liaison)
+				this.#unseat(authorId)
+			}
+		})
+	}
+
+	#unseat(authorId: AuthorId) {
+		const seat = this.seats.get(authorId)
+		if (!seat) return undefined
+		seat.disconnect()
+		this.seats.delete(authorId)
+		this.on.unseated.pub(seat)
+	}
+
+	disconnectAll() {
+		for (const authorId of this.seats.keys())
+			this.#unseat(authorId)
+	}
+
+	dispose() {
+		this.#cleanup()
+		this.disconnectAll()
+	}
+}
+

package/s/_archive/session/meta/meta-client.ts

@@ -0,0 +1,5 @@
+
+import {asFns, asMessengerRpc} from "@e280/renraku"
+
+export const makeMetaClientApi = () => asMessengerRpc(async _meta => asFns({}))
+

package/s/_archive/session/meta/meta-host.ts

@@ -0,0 +1,18 @@
+
+import {asFns, asMessengerRpc} from "@e280/renraku"
+import {Liaison} from "../../core/liaison.js"
+import {Authority} from "../../core/authority.js"
+
+export const makeMetaHostApi = (options: {
+		authority: Authority<any>,
+		liaison: Liaison<any>
+	}) => asMessengerRpc(async _meta => asFns({
+
+	async hello() {
+		return {
+			hostAuthorId: options.authority.authorId,
+			clientAuthorId: options.liaison.authorId,
+		}
+	},
+}))
+

package/s/_archive/session/meta/types.ts

@@ -0,0 +1,15 @@
+
+import {Fns} from "@e280/renraku"
+import type {makeMetaHostApi} from "./meta-host.js"
+import type {makeMetaClientApi} from "./meta-client.js"
+
+export type CustomApi = {
+	host: Fns
+	client: Fns
+}
+
+export type MetaApi = {
+	host: Awaited<ReturnType<ReturnType<typeof makeMetaHostApi>>>
+	client: Awaited<ReturnType<ReturnType<typeof makeMetaClientApi>>>
+}
+

package/s/_archive/session/parts/client-on.ts

@@ -0,0 +1,8 @@
+
+import {sub} from "@e280/stz"
+import {Seat} from "./seat.js"
+
+export class ClientOn {
+	disconnected = sub<[Seat]>()
+}
+

package/s/_archive/session/parts/fiber-rpc.ts

@@ -0,0 +1,28 @@
+
+import {Fiber} from "../../core/fiber.js"
+import {Conduit, Fns, JsonRpc, Messenger, MessengerRpc, Remote} from "@e280/renraku"
+
+export class FiberConduit extends Conduit {
+	constructor(public fiber: Fiber<JsonRpc.Bidirectional>) {
+		super()
+		this.sendRequest.sub(m => fiber.reliable.send(m))
+		this.sendResponse.sub(m => fiber.reliable.send(m))
+		fiber.reliable.recv.on(m => this.recv.pub(m, {origin: ""}))
+	}
+}
+
+export class FiberRpc<RemoteFns extends Fns> {
+	remote: Remote<RemoteFns>
+	dispose: () => void
+
+	constructor(public fiber: Fiber<JsonRpc.Bidirectional>, rpc: MessengerRpc<any, RemoteFns>) {
+		const messenger = new Messenger<any, RemoteFns>({
+			rpc,
+			conduit: new FiberConduit(fiber),
+			timeout: 60_000,
+		})
+		this.remote = messenger.remote
+		this.dispose = () => {}
+	}
+}
+

package/s/_archive/session/parts/host-on.ts

@@ -0,0 +1,9 @@
+
+import {sub} from "@e280/stz"
+import {Seat} from "./seat.js"
+
+export class HostOn {
+	seated = sub<[Seat]>()
+	unseated = sub<[Seat]>()
+}
+

package/s/_archive/session/parts/hub.ts

@@ -0,0 +1,40 @@
+
+import {Spoke} from "./spoke.js"
+
+export type SpokeListener = (spoke: Spoke) => () => void
+
+export class Hub {
+	spokes = new Set<Spoke>()
+	#listeners = new Set<SpokeListener>()
+
+	/** an incoming spoke has appeared, dispatch all onSpoke listeners */
+	addSpoke(spoke: Spoke) {
+		this.spokes.add(spoke)
+
+		const disconnectedFns: (() => void)[] = []
+
+		for (const fn of this.#listeners) {
+
+			// call every spoke listener
+			const spokeDisconnected = fn(spoke)
+
+			// accumulate each listener's disconnected callback
+			disconnectedFns.push(spokeDisconnected)
+		}
+
+		// when this spoke is disconnected, call every listener's disconnected callback
+		return () => {
+			this.spokes.delete(spoke)
+			disconnectedFns.forEach(d => d())
+		}
+	}
+
+	/** add a spoke listener to respond to incoming spokes */
+	onSpoke(fn: SpokeListener) {
+		this.#listeners.add(fn)
+
+		// callback to remove this listener
+		return () => void this.#listeners.delete(fn)
+	}
+}
+

package/s/_archive/session/parts/netfibers.ts

@@ -0,0 +1,14 @@
+
+import {JsonRpc} from "@e280/renraku"
+import {Fiber} from "../../core/fiber.js"
+
+export class Netfibers {
+	sub = {
+		primary: new Fiber(),
+		userland: new Fiber(),
+		meta: new Fiber<JsonRpc.Bidirectional>(),
+	}
+
+	megafiber = Fiber.multiplex(this.sub)
+}
+

package/s/_archive/session/parts/seat.ts

@@ -0,0 +1,35 @@
+
+import {asMessengerRpc, Fns} from "@e280/renraku"
+
+import {Spoke} from "./spoke.js"
+import {FiberRpc} from "./fiber-rpc.js"
+import {Liaison} from "../../core/liaison.js"
+
+export class Seat {
+	constructor(
+			private spoke: Spoke,
+			private liaison: Liaison<any>,
+		) {
+	}
+
+	get authorId() {
+		return this.liaison.authorId
+	}
+
+	get rtt() {
+		return this.liaison.pingponger.averageRtt
+	}
+
+	get userland() {
+		return this.spoke.fibers.sub.userland
+	}
+
+	disconnect() {
+		this.spoke.disconnect()
+	}
+
+	userlandApi<RemoteFns extends Fns>(seat: Seat, hostFns: RemoteFns) {
+		return new FiberRpc<RemoteFns>(seat.userland, asMessengerRpc(async _meta => ({fns: hostFns}))).remote
+	}
+}
+

package/s/_archive/session/parts/spoke.ts

@@ -0,0 +1,10 @@
+
+import {Netfibers} from "./netfibers.js"
+
+export class Spoke {
+	constructor(
+		public fibers: Netfibers,
+		public disconnect: () => void,
+	) {}
+}
+

package/s/_archive/sugar/easy-host.ts

@@ -0,0 +1,68 @@
+
+import {sub} from "@e280/stz"
+import {Ticker} from "../tools/ticker.js"
+import {Hub} from "../session/parts/hub.js"
+import {Fiber} from "../core/fiber.js"
+import {Simulator} from "../core/simulator.js"
+import {SessionHost} from "../session/host.js"
+import {Spoke} from "../session/parts/spoke.js"
+import {SessionClient} from "../session/client.js"
+import {Netfibers} from "../session/parts/netfibers.js"
+import {HubSparrowOptions, startSparrowHost} from "../transports/sparrow/start-sparrow-host.js"
+
+export type EasyHostOptions<xSimulator extends Simulator> = {
+	hz: number
+	makeSimulator: () => xSimulator,
+	closed?: () => void
+	sparrow?: HubSparrowOptions
+}
+
+export class EasyHost<xSimulator extends Simulator> {
+	hub = new Hub()
+	onClosed = sub()
+
+	session: SessionHost<xSimulator>
+	ticker: Ticker
+
+	constructor(public options: EasyHostOptions<xSimulator>) {
+		this.session = new SessionHost<xSimulator>(this.hub, options.makeSimulator())
+		this.ticker = this.session.authority.makeTicker(options.hz)
+	}
+
+	async startHostingViaSparrow(sparrow?: HubSparrowOptions) {
+		return startSparrowHost({
+			sparrow,
+			hub: this.hub,
+			closed: () => this.onClosed.pub(),
+		})
+	}
+
+	async localClient() {
+		// establish fibers on both sides
+		const fibers = {
+			host: new Netfibers(),
+			client: new Netfibers(),
+		}
+
+		// entangle the host and client fibers
+		Fiber.entangle(fibers.host.megafiber, fibers.client.megafiber)
+
+		// create spokes
+		const spokes = {
+			host: new Spoke(fibers.host, () => {}),
+			client: new Spoke(fibers.client, () => {}),
+		}
+
+		// add the host-side spoke the host hub
+		this.hub.addSpoke(spokes.host)
+
+		// create a session client using the client spoke
+		return SessionClient.make<xSimulator>({
+			hz: this.options.hz,
+			spoke: spokes.client,
+			pastSimulator: this.options.makeSimulator(),
+			futureSimulator: this.options.makeSimulator(),
+		})
+	}
+}
+

package/s/_archive/tests.test.ts

@@ -0,0 +1,17 @@
+
+import {Science} from "@e280/science"
+import eureka from "./eureka/testing/eureka.test.js"
+import parcels from "./core/parcels/parcels.test.js"
+import contact from "./core/contact/contact.test.js"
+import integration from "./eureka/testing/integration.test.js"
+
+import ecs from "../alpha/ecs/test.js"
+import sim from "../alpha/sim/test.js"
+
+await Science.run({
+	alpha: {ecs, sim},
+	eureka,
+	integration,
+	archimedes: {parcels, contact},
+})
+

package/s/_archive/tools/averager.ts

@@ -0,0 +1,29 @@
+
+export class Averager {
+	#memory: number[] = []
+	#average: number = 0
+	#latest: number = 0
+
+	constructor(public size: number) {}
+
+	get average() { return this.#average }
+	get latest() { return this.#latest }
+
+	add(n: number) {
+		this.#latest = n
+		const memory = this.#memory
+
+		memory.push(n)
+
+		while (memory.length > this.size)
+			memory.shift()
+
+		if (memory.length > 0) {
+			const sum = memory.reduce((p, c) => p + c, 0)
+			this.#average = sum / memory.length
+		}
+
+		return this.#average
+	}
+}
+

package/s/_archive/tools/bucket.ts

@@ -0,0 +1,17 @@
+
+export class Bucket<T> {
+	#items: T[] = []
+
+	/** put an item in the bucket */
+	give(item: T) {
+		this.#items.push(item)
+	}
+
+	/** extract all items out of the bucket */
+	take() {
+		const items = this.#items
+		this.#items = []
+		return items
+	}
+}
+

package/s/_archive/tools/chronicle.ts

@@ -0,0 +1,32 @@
+
+export type Chron<X> = {item: X, time: number}
+
+export class Chronicle<X> {
+	#chrons: Chron<X>[] = []
+
+	constructor(public limit = 100) {}
+
+	add(item: X, time: number) {
+		this.#chrons.push({item, time})
+		this.#limit()
+	}
+
+	at(time: number) {
+		return this.#chrons
+			.filter(chron => chron.time === time)
+			.map(chron => chron.item)
+	}
+
+	since(time: number) {
+		return this.#chrons
+			.filter(chron => chron.time > time)
+			.map(chron => chron.item)
+	}
+
+	#limit() {
+		const {limit} = this
+		while (this.#chrons.length > limit)
+			this.#chrons.shift()
+	}
+}
+

package/s/_archive/tools/disposers.ts

@@ -0,0 +1,5 @@
+
+export function disposers(...fns: (() => void)[]) {
+	return () => fns.forEach(fn => fn())
+}
+

package/s/_archive/tools/id-counter.ts

@@ -0,0 +1,13 @@
+
+export class IdCounter {
+	count: number
+
+	constructor(start: number = 0) {
+		this.count = start
+	}
+
+	next() {
+		return this.count++
+	}
+}
+

package/s/_archive/tools/loop.ts

@@ -0,0 +1,12 @@
+
+export function* loop(n: number) {
+	for (let i = 0; i < n; i++)
+		yield i
+}
+
+export function* loop2d([columns, rows]: [number, number]) {
+	for (let y = 0; y < rows; y++)
+		for (let x = 0; x < columns; x++)
+			yield [x, y] as [number, number]
+}
+

package/s/_archive/tools/pub.ts

@@ -0,0 +1,22 @@
+
+export type Fn<P extends any[]> = (...p: P) => void
+
+export function pub<P extends any[]>(fn?: Fn<P>) {
+	const fns = new Set<Fn<P>>()
+
+	if (fn)
+		fns.add(fn)
+
+	function publish(...p: P) {
+		for (const fn of fns)
+			fn(...p)
+	}
+
+	publish.on = (fn: Fn<P>) => {
+		fns.add(fn)
+		return () => { fns.delete(fn) }
+	}
+
+	return publish
+}
+

package/s/_archive/tools/ticker.ts

@@ -0,0 +1,22 @@
+
+export class Ticker {
+	#active = false
+	constructor(public hz: number, private fn: () => void) {}
+
+	start() {
+		if (!this.#active) {
+			this.#active = true
+			const tick = () => {
+				if (!this.#active) return undefined
+				this.fn()
+				setTimeout(tick, 1000 / this.hz)
+			}
+		}
+		return () => this.stop()
+	}
+
+	stop() {
+		this.#active = false
+	}
+}
+

package/s/_archive/tools/u8.ts

@@ -0,0 +1,7 @@
+
+export function u8(bytes: Uint8Array) {
+	return (bytes.buffer instanceof ArrayBuffer)
+		? bytes as Uint8Array<ArrayBuffer>
+		: new Uint8Array(bytes)
+}
+

package/s/_archive/transports/sparrow/fibers.ts

@@ -0,0 +1,19 @@
+
+import {Sparrow} from "sparrow-rtc"
+import {netfibersFromCable} from "./utils/netfibers-from-cable.js"
+
+export async function sparrowFibers(options: {
+		invite: string,
+		disconnected: () => void,
+	}) {
+
+	const sparrow = await Sparrow.join({
+		invite: options.invite,
+		disconnected: options.disconnected,
+	})
+
+	const fibers = netfibersFromCable(sparrow.connection.cable)
+
+	return {sparrow, fibers}
+}
+

package/s/_archive/transports/sparrow/start-sparrow-host.ts

@@ -0,0 +1,26 @@
+
+import {ConnectOptions, Sparrow, StdCable} from "sparrow-rtc"
+import {Hub} from "../../session/parts/hub.js"
+import {Spoke} from "../../session/parts/spoke.js"
+import {netfibersFromCable} from "./utils/netfibers-from-cable.js"
+
+export type HubSparrowOptions = Omit<ConnectOptions<StdCable>, "closed" | "welcome" | "cableConfig">
+
+export async function startSparrowHost(options: {
+		hub: Hub
+		closed: () => void
+		sparrow?: HubSparrowOptions
+	}) {
+
+	return Sparrow.host({
+		...(options.sparrow ?? {}),
+		closed: options.closed,
+		welcome: _prospect => connection => {
+			const fibers = netfibersFromCable(connection.cable)
+			const disconnect = () => connection.disconnect()
+			const spoke = new Spoke(fibers, disconnect)
+			return options.hub.addSpoke(spoke)
+		},
+	})
+}
+