@loadmap/sim 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jaime Rojas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,6 @@
-# Temporary Holding Version
+# @loadmap/sim
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The fluid queue simulation behind [loadmap](https://jaim3r0jas.github.io/loadmap/)'s moving dots: priorities, drop
+rules, workers filling up, seeded randomness so a recording is the same every time. It never has capacity numbers of
+its own: a stage drains what its flows carry at the load where its component is full. Used by `@loadmap/react`; you
+rarely need it directly. MIT.

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+import { Evaluation, Model } from "@loadmap/core";
+interface Fill {
+  /** rank[i]: the order in which worker i takes work. */
+  rank: readonly number[];
+  /** Small per-worker weights around 1, so equal shares do not look machine-made. */
+  jitter: readonly number[];
+}
+/**
+ * The order workers take work. Round-robin: one worker of each pod in turn, a shuffled one inside each pod, so load
+ * spreads evenly across pods instead of filling pod 0 top to bottom. In-order: pod 0 first.
+ */
+export declare function fillOrder(pods: number, perPod: number, fill: 'round-robin' | 'in-order', seed?: number): Fill;
+/** How busy worker i is (0–1) when the pool as a whole is `util` busy. */
+export declare function busyOf(i: number, f: Fill, util: number): number;
+/** mulberry32: a small seeded generator, so a scenario plays the same way every time (export depends on it). */
+export declare function rng(seed: number): () => number;
+interface SimOptions {
+  seed?: number;
+  /** Simulated seconds per real second. Default 10. */
+  speed?: number;
+  /** About how many dots a second all flows together should spawn; sets the dot scale. Default 28. */
+  dotTarget?: number;
+  /** Every flow with any rate spawns at least this many dots a second, so a small flow stays visible. Default 1. */
+  minDots?: number;
+  /** And at most this many per flow. Default 40. */
+  maxDots?: number;
+  /** Real seconds a dot takes from one stage to the next. Default 0.45. */
+  legSeconds?: number;
+  /** Most dots alive at once. Default 800. */
+  maxParticles?: number;
+}
+/** Where a dot is or is heading: a stage (null: the flow's source), and a cell inside it (partition or worker). */
+interface Place {
+  stage: string | null;
+  cell?: number;
+}
+interface Particle {
+  id: number;
+  flow: string;
+  /** Index into the flow's route of the stage it is heading to or at. */
+  leg: number;
+  phase: 'move' | 'hold' | 'fade';
+  /** Real seconds into the current phase, and its length. */
+  t: number;
+  dur: number;
+  from: Place;
+  to: Place;
+  /** Set on a copy made at a fan-out: the branch stage it is heading to. */
+  branch?: string;
+  /** superseded: merged into a newer unit of its key; unread: a fan-out that made no copy. */
+  outcome?: 'delivered' | 'dropped' | 'rejected' | 'superseded' | 'unread';
+}
+interface QueueState {
+  /** Units waiting. */
+  backlog: number;
+  /** Age of the oldest unit waiting, in simulated seconds: what a consumer-lag dashboard shows. */
+  lag: number;
+  /** Units per second arriving, served, dropped and superseded by a merge (smoothed). */
+  arriving: number;
+  served: number;
+  dropped: number;
+  merged: number;
+  /** A merge rule is at work: more than a second of arrivals waits. */
+  merging: boolean;
+}
+/**
+ * A fluid model of the queues, driven by the model's utilization, plus dots sampled from it.
+ *
+ * Each queue stage is drained by the next stage on each flow's route, at that stage's capacity: what its flows carry
+ * at the load where its component runs out (the limits' "full at N×"), so a queue grows exactly when the load passes
+ * the point the bars show. Flows share that capacity by priority (1 first), across every queue feeding the stage.
+ * Backlog is kept as arrival cohorts, so the lag is the real age of the oldest unit and a drop rule can remove
+ * exactly the units older than its limit.
+ */
+export declare class Sim {
+  #private;
+  readonly speed: number;
+  time: number;
+  particles: Particle[];
+  dotScale: number;
+  constructor(model: Model, ev: Evaluation, o?: SimOptions);
+  /**
+   * New values or a new evaluation: rates and capacities change, backlog stays. A new shape (partitions, workers)
+   * keeps every dot whose partition or worker still exists, so switching designs does not empty the picture.
+   */
+  update(ev: Evaluation): void;
+  /** Advance by `dtReal` real seconds: the queues by dtReal × speed, the dots by dtReal. */
+  step(dtReal: number, o?: {
+    particles?: boolean;
+  }): void;
+  queue(stage: string, flow: string): QueueState;
+  /** How busy a stage is, 0–1, smoothed: for a workers stage, the share of its workers at work. */
+  busy(stage: string): number;
+  /** The share a pass stage (arrivals) or a fan-out (copies) rejects because its component is past capacity. */
+  shed(stage: string): number;
+  /** How busy worker `i` of a workers stage is, 0–1. */
+  slotBusy(stage: string, i: number): number;
+}
+export declare function createSim(model: Model, ev: Evaluation, o?: SimOptions): Sim;
+export type { Fill, Particle, Place, QueueState, SimOptions };

package/dist/index.js

@@ -0,0 +1,441 @@
+import { niceStep } from "@loadmap/core/format";
+// src/rng.ts
+/** mulberry32: a small seeded generator, so a scenario plays the same way every time (export depends on it). */
+function rng(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = a;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+// src/fill.ts
+/** Busy workers run at this share before the next one takes work, so a half-busy pool shows a spread, not a block. */
+const SPILL = .7;
+/**
+* The order workers take work. Round-robin: one worker of each pod in turn, a shuffled one inside each pod, so load
+* spreads evenly across pods instead of filling pod 0 top to bottom. In-order: pod 0 first.
+*/
+function fillOrder(pods, perPod, fill, seed = 1) {
+	const n = pods * perPod;
+	const rank = new Array(n);
+	const r = rng(seed);
+	for (let p = 0; p < pods; p++) {
+		const perm = Array.from({ length: perPod }, (_, t) => t);
+		for (let t = perPod - 1; t > 0; t--) {
+			const j = Math.floor(r() * (t + 1));
+			[perm[t], perm[j]] = [perm[j], perm[t]];
+		}
+		perm.forEach((t, slot) => {
+			rank[p * perPod + t] = fill === "round-robin" ? slot * pods + p : p * perPod + slot;
+		});
+	}
+	const w = Array.from({ length: n }, () => .92 + r() * .16);
+	const mean = w.reduce((a, b) => a + b, 0) / (n || 1);
+	return {
+		rank,
+		jitter: w.map((x) => x / mean)
+	};
+}
+/** How busy worker i is (0–1) when the pool as a whole is `util` busy. */
+function busyOf(i, f, util) {
+	const n = f.rank.length;
+	const total = Math.min(1, Math.max(0, util)) * n;
+	const k = f.rank[i];
+	let b;
+	if (total <= SPILL * n) {
+		const full = Math.floor(total / SPILL);
+		b = k < full ? SPILL : k === full ? total - full * SPILL : 0;
+	} else b = SPILL + (total - SPILL * n) / n;
+	return Math.min(1, Math.max(0, b * (f.jitter[i] ?? 1)));
+}
+// src/sim.ts
+const emptyQueue = () => ({
+	backlog: 0,
+	lag: 0,
+	arriving: 0,
+	served: 0,
+	dropped: 0,
+	merged: 0,
+	merging: false
+});
+const MERGE_WINDOW = 1;
+const MAX_COHORTS = 2e3;
+const TAU = 3;
+/**
+* A fluid model of the queues, driven by the model's utilization, plus dots sampled from it.
+*
+* Each queue stage is drained by the next stage on each flow's route, at that stage's capacity: what its flows carry
+* at the load where its component runs out (the limits' "full at N×"), so a queue grows exactly when the load passes
+* the point the bars show. Flows share that capacity by priority (1 first), across every queue feeding the stage.
+* Backlog is kept as arrival cohorts, so the lag is the real age of the oldest unit and a drop rule can remove
+* exactly the units older than its limit.
+*/
+var Sim = class {
+	speed;
+	time = 0;
+	particles = [];
+	dotScale = 1;
+	#o;
+	#r;
+	#model;
+	#ev;
+	#shape = "";
+	#queues = /* @__PURE__ */ new Map();
+	#busy = /* @__PURE__ */ new Map();
+	#fills = /* @__PURE__ */ new Map();
+	#shed = /* @__PURE__ */ new Map();
+	#inflow = /* @__PURE__ */ new Map();
+	#capacity = /* @__PURE__ */ new Map();
+	#spawn = /* @__PURE__ */ new Map();
+	#nextId = 1;
+	constructor(model, ev, o = {}) {
+		this.#o = {
+			seed: 1,
+			speed: 10,
+			dotTarget: 28,
+			minDots: 1,
+			maxDots: 40,
+			legSeconds: .45,
+			maxParticles: 800,
+			...o
+		};
+		this.speed = this.#o.speed;
+		this.#r = rng(this.#o.seed);
+		this.#model = model;
+		this.update(ev);
+		for (const s of Object.values(ev.stages)) if (s.kind === "workers") this.#busy.set(s.id, this.#steadyBusy(s.id));
+	}
+	/**
+	* New values or a new evaluation: rates and capacities change, backlog stays. A new shape (partitions, workers)
+	* keeps every dot whose partition or worker still exists, so switching designs does not empty the picture.
+	*/
+	update(ev) {
+		this.#ev = ev;
+		const shape = JSON.stringify(Object.values(ev.stages).map((st) => st.kind === "queue" ? [st.id, st.partitions] : st.kind === "workers" ? [
+			st.id,
+			st.pods,
+			st.perPod,
+			st.fill
+		] : [st.id, st.kind]));
+		if (shape !== this.#shape) {
+			this.#shape = shape;
+			const fits = (at, flow) => {
+				if (at.stage == null) return true;
+				const st = ev.stages[at.stage];
+				if (!st) return false;
+				if (at.cell == null) return true;
+				if (st.kind === "queue") return at.cell < (st.partitions[flow] ?? 0);
+				if (st.kind === "workers") return at.cell < st.pods * st.perPod;
+				return false;
+			};
+			this.particles = this.particles.filter((d) => fits(d.from, d.flow) && fits(d.to, d.flow));
+			for (const s of Object.values(ev.stages)) if (s.kind === "workers") this.#fills.set(s.id, fillOrder(s.pods, s.perPod, s.fill, this.#o.seed));
+		}
+		const full = this.#model.thresholds.full;
+		this.#shed.clear();
+		this.#inflow.clear();
+		for (const s of Object.values(ev.stages)) {
+			const u = (s.kind === "pass" || s.kind === "fanout") && s.component ? this.#util(s.component) : null;
+			this.#shed.set(s.id, u != null && u > full ? 1 - full / u : 0);
+		}
+		for (const f of this.#model.flowIds) {
+			let rate = ev.flows[f] ?? 0;
+			for (const st of ev.routes[f] ?? []) {
+				this.#inflow.set(`${st}/${f}`, rate);
+				rate *= 1 - (this.#shed.get(st) ?? 0);
+			}
+		}
+		this.#capacity.clear();
+		const routedThrough = (s) => this.#model.flowIds.filter((f) => ev.routes[f]?.includes(s));
+		for (const s of Object.values(ev.stages)) {
+			const c = s.component ? ev.components[s.component] : void 0;
+			let cap = Number.POSITIVE_INFINITY;
+			if (c && c.util != null && c.full != null && Number.isFinite(c.full)) {
+				if (c.full > 0) {
+					const at = this.#model.evaluate({
+						...ev.values,
+						load: c.full
+					});
+					cap = routedThrough(s.id).reduce((a, f) => a + (at.flows[f] ?? 0), 0);
+				} else {
+					const now = routedThrough(s.id).reduce((a, f) => a + (this.#inflow.get(`${s.id}/${f}`) ?? 0), 0);
+					cap = c.util > 0 ? now * full / c.util : 0;
+				}
+			}
+			this.#capacity.set(s.id, cap);
+		}
+		const total = this.#model.flowIds.reduce((a, f) => a + (ev.flows[f] ?? 0), 0);
+		this.dotScale = Math.max(1, niceStep(total / this.#o.dotTarget));
+	}
+	/** Advance by `dtReal` real seconds: the queues by dtReal × speed, the dots by dtReal. */
+	step(dtReal, o = {}) {
+		if (!(dtReal > 0)) return;
+		const dt = dtReal * this.speed;
+		this.time += dt;
+		this.#stepQueues(dt);
+		if (o.particles !== false) {
+			this.#spawnDots(dtReal);
+			this.#moveDots(dtReal);
+		}
+	}
+	queue(stage, flow) {
+		return this.#queues.get(stage)?.get(flow)?.s ?? emptyQueue();
+	}
+	/** How busy a stage is, 0–1, smoothed: for a workers stage, the share of its workers at work. */
+	busy(stage) {
+		return this.#busy.get(stage) ?? this.#steadyBusy(stage);
+	}
+	/** The share a pass stage (arrivals) or a fan-out (copies) rejects because its component is past capacity. */
+	shed(stage) {
+		return this.#shed.get(stage) ?? 0;
+	}
+	/** How busy worker `i` of a workers stage is, 0–1. */
+	slotBusy(stage, i) {
+		const f = this.#fills.get(stage);
+		return f ? busyOf(i, f, this.busy(stage)) : 0;
+	}
+	#util(component) {
+		return this.#ev.components[component]?.util ?? null;
+	}
+	#steadyBusy(stage) {
+		const s = this.#ev.stages[stage];
+		const u = s?.component ? this.#util(s.component) : null;
+		return Math.min(1, (u ?? 0) / this.#model.thresholds.full);
+	}
+	#stepQueues(dt) {
+		const ev = this.#ev;
+		const entries = [];
+		for (const q of Object.values(ev.stages)) {
+			if (q.kind !== "queue") continue;
+			const qs = this.#queues.get(q.id) ?? /* @__PURE__ */ new Map();
+			this.#queues.set(q.id, qs);
+			for (const f of this.#model.flowIds) {
+				const route = ev.routes[f] ?? [];
+				if (!route.includes(q.id)) continue;
+				const fq = qs.get(f) ?? {
+					cohorts: [],
+					s: emptyQueue()
+				};
+				qs.set(f, fq);
+				const inflow = this.#inflow.get(`${q.id}/${f}`) ?? 0;
+				const share = Math.min(.95, Math.max(0, ev.overload[f]?.merge?.share ?? 0));
+				fq.s.merging = share > 0 && backlog(fq.cohorts) > inflow * 1;
+				const n = inflow * dt;
+				const last = fq.cohorts.at(-1);
+				if (last && this.time - last.t < MERGE_WINDOW) last.n += n;
+				else if (n > 0) fq.cohorts.push({
+					t: this.time,
+					n
+				});
+				if (fq.cohorts.length > MAX_COHORTS) fq.cohorts = mergePairs(fq.cohorts);
+				const drainer = route[route.indexOf(q.id) + 1] ?? "∞";
+				const k = fq.s.merging ? 1 / (1 - share) : 1;
+				entries.push({
+					q: q.id,
+					f,
+					fq,
+					drainer,
+					prio: this.#model.def.flows[f]?.priority ?? 1,
+					k
+				});
+			}
+		}
+		const taken = /* @__PURE__ */ new Map();
+		for (const d of new Set(entries.map((e) => e.drainer))) {
+			const feeding = entries.filter((e) => e.drainer === d);
+			let avail = d === "∞" ? Number.POSITIVE_INFINITY : (this.#capacity.get(d) ?? Number.POSITIVE_INFINITY) * dt;
+			for (const pr of [...new Set(feeding.map((e) => e.prio))].sort((a, b) => a - b)) {
+				const group = feeding.filter((e) => e.prio === pr);
+				const want = group.reduce((a, e) => a + backlog(e.fq.cohorts) / e.k, 0);
+				let took = 0;
+				for (const e of group) {
+					const b = backlog(e.fq.cohorts);
+					const removed = Number.isFinite(avail) ? want > 0 ? Math.min(b, avail * b / want) : 0 : b;
+					const used = removed / e.k;
+					serveOldest(e.fq.cohorts, removed);
+					took += used;
+					e.fq.s.served = ema(e.fq.s.served, used / dt, dt);
+					e.fq.s.merged = ema(e.fq.s.merged, (removed - used) / dt, dt);
+				}
+				avail = Math.max(0, avail - took);
+				taken.set(d, (taken.get(d) ?? 0) + took);
+			}
+		}
+		for (const { q, f, fq } of entries) {
+			let dropped = 0;
+			const rule = ev.overload[f]?.drop;
+			if (rule) while (fq.cohorts.length && this.time - fq.cohorts[0].t > rule.olderThan) dropped += fq.cohorts.shift().n;
+			const inflow = this.#inflow.get(`${q}/${f}`) ?? 0;
+			if (backlog(fq.cohorts) < 1e-9 * Math.max(1, inflow)) fq.cohorts = [];
+			fq.s.backlog = backlog(fq.cohorts);
+			fq.s.lag = fq.cohorts.length ? this.time - fq.cohorts[0].t : 0;
+			fq.s.arriving = ema(fq.s.arriving, inflow, dt);
+			fq.s.dropped = ema(fq.s.dropped, dropped / dt, dt);
+		}
+		for (const s of Object.values(ev.stages)) {
+			if (s.kind !== "workers") continue;
+			const cap = this.#capacity.get(s.id) ?? Number.POSITIVE_INFINITY;
+			const now = taken.has(s.id) && Number.isFinite(cap) && cap > 0 ? taken.get(s.id) / (cap * dt) : this.#steadyBusy(s.id);
+			this.#busy.set(s.id, ema(this.#busy.get(s.id) ?? now, Math.min(1, now), dt));
+		}
+	}
+	#spawnDots(dtReal) {
+		const { minDots, maxDots, legSeconds, maxParticles } = this.#o;
+		for (const f of this.#model.flowIds) {
+			const rate = this.#ev.flows[f] ?? 0;
+			if (rate <= 0) continue;
+			const perSec = Math.min(maxDots, Math.max(minDots, rate / this.dotScale));
+			let acc = (this.#spawn.get(f) ?? 0) + perSec * dtReal;
+			while (acc >= 1) {
+				acc -= 1;
+				if (this.particles.length >= maxParticles) continue;
+				const first = this.#ev.routes[f][0];
+				this.particles.push({
+					id: this.#nextId++,
+					flow: f,
+					leg: 0,
+					phase: "move",
+					t: 0,
+					dur: legSeconds,
+					from: { stage: null },
+					to: this.#place(first, f)
+				});
+			}
+			this.#spawn.set(f, acc);
+		}
+	}
+	#moveDots(dtReal) {
+		const ev = this.#ev;
+		const fade = (d, outcome, dur) => {
+			d.phase = "fade";
+			d.outcome = outcome;
+			d.t = 0;
+			d.dur = dur;
+			d.from = d.to;
+		};
+		const advance = (d) => {
+			const route = ev.routes[d.flow];
+			if (d.leg + 1 >= route.length) return fade(d, "delivered", .35);
+			d.leg++;
+			d.phase = "move";
+			d.t = 0;
+			d.dur = this.#o.legSeconds;
+			d.from = d.to;
+			d.to = this.#place(route[d.leg], d.flow);
+		};
+		const born = [];
+		for (const d of this.particles) {
+			d.t += dtReal;
+			if (d.t < d.dur) continue;
+			const stage = ev.stages[d.to.stage ?? ""];
+			if (d.phase === "fade" || !stage) {
+				d.phase = "fade";
+				d.outcome ??= "delivered";
+				continue;
+			}
+			if (d.phase === "move" && d.branch) fade(d, this.#r() < this.shed(d.from.stage ?? "") || stage.kind === "pass" && this.#r() < this.shed(stage.id) ? "rejected" : "delivered", .35);
+			else if (d.phase === "move" && stage.kind === "fanout") {
+				let made = 0;
+				for (const b of stage.to[d.flow] ?? []) {
+					const copies = Math.floor(b.share) + (this.#r() < b.share % 1 ? 1 : 0);
+					for (let i = 0; i < copies; i++, made++) if (this.particles.length + born.length < this.#o.maxParticles) born.push({
+						id: this.#nextId++,
+						flow: d.flow,
+						leg: d.leg,
+						phase: "move",
+						t: 0,
+						dur: this.#o.legSeconds,
+						from: d.to,
+						to: { stage: b.stage },
+						branch: b.stage
+					});
+				}
+				if (made) fade(d, "delivered", 0);
+				else fade(d, "unread", .6);
+			} else if (d.phase === "move") {
+				if (stage.kind === "pass" && this.#r() < this.shed(stage.id)) fade(d, "rejected", .6);
+				else if (stage.kind === "queue") {
+					const lag = this.queue(stage.id, d.flow).lag;
+					d.phase = "hold";
+					d.t = 0;
+					d.dur = .12 + Math.min(lag, 120) / 120 * 2.6;
+				} else if (stage.kind === "workers") {
+					d.phase = "hold";
+					d.t = 0;
+					d.dur = .15;
+				} else advance(d);
+			} else if (d.phase === "hold") {
+				const q = stage.kind === "queue" ? this.queue(stage.id, d.flow) : null;
+				const dropShare = q && q.arriving > 0 ? Math.min(1, q.dropped / q.arriving) : 0;
+				const mergeShare = q?.merging ? ev.overload[d.flow]?.merge?.share ?? 0 : 0;
+				if (this.#r() < mergeShare) fade(d, "superseded", .6);
+				else if (this.#r() < dropShare) fade(d, "dropped", .6);
+				else advance(d);
+			}
+		}
+		this.particles = this.particles.filter((d) => !(d.phase === "fade" && d.t >= d.dur)).concat(born);
+	}
+	#place(stage, flow) {
+		const s = this.#ev.stages[stage];
+		if (s?.kind === "queue") {
+			const n = s.partitions[flow] ?? 0;
+			return n > 0 ? {
+				stage,
+				cell: Math.floor(this.#r() * n)
+			} : { stage };
+		}
+		if (s?.kind === "workers") return {
+			stage,
+			cell: this.#pickWorker(s.id, s.pods * s.perPod)
+		};
+		return { stage };
+	}
+	/** A worker chosen in proportion to how busy it is, so dots land where the fill shows work. */
+	#pickWorker(stage, n) {
+		let total = 0;
+		for (let i = 0; i < n; i++) total += this.slotBusy(stage, i);
+		if (total <= .001) return Math.floor(this.#r() * n);
+		let r = this.#r() * total;
+		for (let i = 0; i < n; i++) {
+			r -= this.slotBusy(stage, i);
+			if (r <= 0) return i;
+		}
+		return n - 1;
+	}
+};
+function createSim(model, ev, o) {
+	return new Sim(model, ev, o);
+}
+const backlog = (c) => c.reduce((a, x) => a + x.n, 0);
+function serveOldest(c, amount) {
+	let left = amount;
+	while (left > 0 && c.length) {
+		const head = c[0];
+		if (head.n <= left) {
+			left -= head.n;
+			c.shift();
+		} else {
+			head.n -= left;
+			left = 0;
+		}
+	}
+}
+function mergePairs(c) {
+	const out = [];
+	for (let i = 0; i < c.length; i += 2) {
+		const a = c[i];
+		const b = c[i + 1];
+		out.push(b ? {
+			t: a.t,
+			n: a.n + b.n
+		} : a);
+	}
+	return out;
+}
+function ema(prev, now, dt) {
+	return prev + (now - prev) * Math.min(1, dt / TAU);
+}
+export { Sim, busyOf, createSim, fillOrder, rng };

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@loadmap/sim",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "The fluid queue simulation behind loadmap's moving dots: priorities, drop rules, worker fill, seeded randomness.",
+  "keywords": [
+    "loadmap",
+    "simulation",
+    "queue"
+  ],
+  "license": "MIT",
+  "author": "Jaime Rojas",
+  "homepage": "https://jaim3r0jas.github.io/loadmap/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaim3r0jas/loadmap.git",
+    "directory": "packages/sim"
+  },
+  "bugs": "https://github.com/jaim3r0jas/loadmap/issues",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@loadmap/core": "0.1.0"
+  },
+  "peerDependencies": {},
+  "scripts": {
+    "build": "tsdown"
+  }
 }