@voltro/plugin-matchmaking 0.0.0-stage → 0.88.0

package/dist/service.js

@@ -0,0 +1,369 @@
+import { MatchmakingError as e, matchmakingError as t } from "./errors.js";
+import { captureJsonData as n, identifier as r, sameJson as i } from "./contract.js";
+import { defaultMatchmakingAvoidPairs as a } from "./avoidPairs.js";
+import { MatchmakingTicketSchema as o } from "./ticketContract.js";
+import { matchmakingAssignmentsTable as s, matchmakingTicketsTable as c } from "./tickets.entity.js";
+import { matchmakingQueuesTable as l, matchmakingSubjectsTable as u } from "./admission.entity.js";
+import { readMatchmakingAssignments as d } from "./assignment.js";
+import { captureQueueDeclarations as f } from "./queueDeclarations.js";
+import { dataStoreMatchmakingPlanner as p } from "./director.js";
+import { Effect as m, Schema as h } from "effect";
+import { and as g, eq as _, gt as v, queryFor as y } from "@voltro/database";
+import { createHash as b } from "node:crypto";
+// src/service.ts
+var x = (e) => b("sha256").update(JSON.stringify(e, (e, t) => typeof t == "object" && t && !Array.isArray(t) ? Object.fromEntries(Object.entries(t).sort(([e], [t]) => e < t ? -1 : +(e > t))) : t)).digest("hex"), S = (e, t) => "mms_" + x([e, t]).slice(0, 56), C = (n) => n instanceof e ? n : t("unavailable"), w = (e) => e === !0 || e === 1, T = (e) => m.tryPromise({
+	try: e,
+	catch: C
+}), E = (e, n) => {
+	let r = e[n];
+	if (typeof r != "string") throw t("unavailable");
+	return r;
+}, D = (e) => {
+	let n = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	if (!Number.isSafeInteger(n) || n < 0) throw t("unavailable");
+	return n;
+}, O = (e) => h.decodeUnknownSync(o)(structuredClone({
+	id: e.id,
+	queue: e.queue,
+	state: e.state,
+	members: e.members,
+	attributes: e.attributes,
+	createdAt: D(e.createdAt),
+	expiresAt: D(e.expiresAt),
+	closedAt: e.closedAt === null ? null : D(e.closedAt),
+	metadata: e.metadata
+})), k = (e) => {
+	if (!e || e.type !== "user") throw t("identity_required");
+	if (!r(e.id) || !r(e.tenantId)) throw t("invalid_input");
+	return n(Object.fromEntries(Object.entries(e).filter(([, e]) => e !== void 0)), 65536);
+}, A = (e) => {
+	if (!Array.isArray(e.queues) || e.queues.length > 256 || typeof e.prepareTicket != "function" || typeof e.admit != "function") throw t("invalid_queue");
+	let n = f(e.queues), r = e.prepareTicket, i = e.admit, o = e.now ?? Date.now, s = e.avoidPairs ?? a, c = e.maxPreferencesBytes ?? 4096, l = e.maxExportRows ?? 1e4;
+	if (!Number.isSafeInteger(c) || c < 1 || c > 65536 || !Number.isSafeInteger(l) || l < 1 || l > 1e5 || typeof o != "function" || typeof s != "function") throw t("invalid_queue");
+	return Object.freeze({
+		queues: Object.freeze(n),
+		prepareTicket: r,
+		admit: i,
+		avoidPairs: s,
+		now: o,
+		maxPreferencesBytes: c,
+		maxExportRows: l
+	});
+}, j = 18e5, M = 18e5, N = 50, P = 200, F = (e, a) => {
+	let o = A(a), f = new Map(o.queues.map((e) => [e.name, e])), b = o.prepareTicket, F = o.admit, I = o.now, L = o.maxPreferencesBytes, R = o.maxExportRows, z = () => {
+		let e = I();
+		if (!Number.isSafeInteger(e) || e < 0 || e > 864e13) throw t("unavailable");
+		return e;
+	}, B = S, V = (e, t) => "mmq_" + x([e, t]).slice(0, 56), H = (e, t, n) => "mmt_" + x([
+		e,
+		t,
+		n
+	]).slice(0, 56), U = (e) => e.partyId !== null && e.partyId !== void 0, W = async (e, n, r, i) => {
+		let a = (await e.query(y(c).where(_("id", i)).limit(1).descriptor))[0];
+		if (a && (a.tenantId !== n || a.subjectId !== r || !Array.isArray(a.members) || !a.members.includes(r) || !U(a) && (a.members.length !== 1 || a.members[0] !== r))) throw t("not_found");
+		return a;
+	}, G = async (e, n, r, i) => {
+		let a = (await e.query(y(c).where(_("id", i)).limit(1).descriptor))[0];
+		if (a) {
+			if (a.tenantId !== n || !Array.isArray(a.members) || !a.members.includes(r) || !U(a) && (a.subjectId !== r || a.members.length !== 1)) throw t("not_found");
+			return a;
+		}
+	}, K = async (t, n) => {
+		let r = B(t, n);
+		try {
+			await e.insertIgnore(u.tableName, {
+				id: r,
+				tenantId: t,
+				subjectId: n,
+				activeTicketId: null,
+				admission: 0,
+				erased: !1
+			}, { conflictColumns: ["id"] });
+		} catch (i) {
+			let a = (await e.query(y(u).where(_("id", r)).limit(1).descriptor))[0];
+			if (!a || a.tenantId !== t || a.subjectId !== n && !w(a.erased)) throw i;
+		}
+	}, q = async (t, n) => {
+		let r = V(t, n);
+		try {
+			await e.insertIgnore(l.tableName, {
+				id: r,
+				tenantId: t,
+				queue: n,
+				admission: 0
+			}, { conflictColumns: ["id"] });
+		} catch (i) {
+			let a = (await e.query(y(l).where(_("id", r)).limit(1).descriptor))[0];
+			if (!a || a.tenantId !== t || a.queue !== n) throw i;
+		}
+	}, J = async (n, r, i, a, o = !1) => (await K(n, r), i !== void 0 && await q(n, i), e.transactional(async (e) => {
+		let s = B(n, r);
+		if (await e.updateMany(u.tableName, { admission: 0 }, { where: _("id", s) }) !== 1) throw t("unavailable");
+		let c = (await e.query(y(u).where(_("id", s)).limit(1).descriptor))[0];
+		if (!c || c.tenantId !== n || c.subjectId !== r && !(o && c.subjectId === null && w(c.erased))) throw t(w(c?.erased) ? "erased" : "unavailable");
+		if (!o && w(c.erased)) throw t("erased");
+		if (i !== void 0) {
+			let r = V(n, i);
+			if (await e.updateMany(l.tableName, { admission: 0 }, { where: _("id", r) }) !== 1) throw t("unavailable");
+			let a = (await e.query(y(l).where(_("id", r)).limit(1).descriptor))[0];
+			if (!a || a.tenantId !== n || a.queue !== i) throw t("unavailable");
+		}
+		return a(e, c);
+	})), Y = (e) => m.suspend(e).pipe(m.mapError(C), m.catchDefect(() => m.fail(t("unavailable")))), X = {
+		enqueue: (e, a) => {
+			let o, s, l;
+			try {
+				if (o = k(e), !r(a.queue) || !r(a.requestId) || !a.preferences || typeof a.preferences != "object" || Array.isArray(a.preferences)) throw t("invalid_input");
+				let i = f.get(a.queue);
+				if (!i) throw t("not_found");
+				l = i, s = Object.freeze({
+					queue: a.queue,
+					requestId: a.requestId,
+					preferences: n(a.preferences, L)
+				});
+			} catch (e) {
+				return m.fail(C(e));
+			}
+			return m.gen(function* () {
+				let e = H(o.tenantId, o.id, s.requestId), r = x([s.queue, s.preferences]), a = yield* T(() => J(o.tenantId, o.id, void 0, (t) => W(t, o.tenantId, o.id, e)));
+				if (a) return a.requestKey !== r || a.queue !== s.queue ? yield* m.fail(t("conflict")) : O(a);
+				let d = yield* Y(() => b(o, l, s.preferences)), f = yield* m.try({
+					try: () => {
+						if (!d || typeof d != "object" || Array.isArray(d)) throw t("invalid_input");
+						let e = n(d, l.maxAttributeBytes), r = h.decodeUnknownSync(l.ticket, { onExcessProperty: "error" })(e);
+						if (!i(e, r)) throw t("invalid_input");
+						return n(r, l.maxAttributeBytes);
+					},
+					catch: C
+				});
+				return yield* T(() => J(o.tenantId, o.id, s.queue, async (n, i) => {
+					let a = await W(n, o.tenantId, o.id, e);
+					if (a) {
+						if (a.requestKey !== r || a.queue !== s.queue) throw t("conflict");
+						return O(a);
+					}
+					let d = z();
+					if (i.activeTicketId !== null) {
+						let e = await G(n, o.tenantId, o.id, E(i, "activeTicketId"));
+						if (!e) throw t("unavailable");
+						if (e.state === "open" && D(e.expiresAt) > d) throw t("already_searching");
+						e.state === "open" && await n.update(c.tableName, E(e, "id"), {
+							state: "expired",
+							closedAt: new Date(d)
+						});
+					}
+					let p = await n.query(y(c).where(g(_("tenantId", o.tenantId), _("queue", s.queue), _("state", "open"), v("expiresAt", new Date(d)))).limit(l.maxTickets + 1).forUpdate().descriptor);
+					if (p.some((e) => e.tenantId !== o.tenantId || e.queue !== s.queue)) throw t("unavailable");
+					if (p.length >= l.maxTickets) throw t("queue_full");
+					if (await m.runPromise(Y(() => F(o, l, n))), d + l.ticketTtlMs > 864e13 || !Number.isSafeInteger(d + l.ticketTtlMs)) throw t("invalid_input");
+					let h = await n.insert(c.tableName, {
+						id: e,
+						tenantId: o.tenantId,
+						subjectId: o.id,
+						queue: s.queue,
+						requestKey: r,
+						partyId: null,
+						members: [o.id],
+						attributes: f,
+						state: "open",
+						createdAt: new Date(d),
+						expiresAt: new Date(d + l.ticketTtlMs),
+						closedAt: null,
+						metadata: {}
+					});
+					return await n.update(u.tableName, E(i, "id"), { activeTicketId: e }), O(h);
+				}));
+			}).pipe(m.catchDefect(() => m.fail(t("unavailable"))));
+		},
+		cancel: (e, n) => {
+			let i;
+			try {
+				if (i = k(e), !r(n)) throw t("invalid_input");
+			} catch (e) {
+				return m.fail(C(e));
+			}
+			return T(() => J(i.tenantId, i.id, void 0, async (e, r) => {
+				let a = await W(e, i.tenantId, i.id, n);
+				if (!a) throw t("not_found");
+				if (U(a)) throw t("forbidden");
+				a.state === "open" && await e.update(c.tableName, n, {
+					state: "cancelled",
+					closedAt: new Date(z())
+				}), r.activeTicketId === n && await e.update(u.tableName, E(r, "id"), { activeTicketId: null });
+			}));
+		},
+		status: (n, i) => {
+			let a;
+			try {
+				if (a = k(n), !r(i)) throw t("invalid_input");
+			} catch (e) {
+				return m.fail(C(e));
+			}
+			return T(async () => {
+				let n = await G(e, a.tenantId, a.id, i);
+				if (!n) throw t("not_found");
+				return O(n);
+			});
+		},
+		estimate: (n, i) => {
+			let a;
+			try {
+				if (a = k(n), !r(i) || !f.has(i)) throw t("invalid_queue");
+			} catch (e) {
+				return m.fail(C(e));
+			}
+			return T(async () => {
+				let t = z() - j, n = await e.query(y(c).where(g(_("tenantId", a.tenantId), _("queue", i), v("createdAt", /* @__PURE__ */ new Date(t - M)))).orderBy("createdAt", "desc").limit(P).descriptor), r = [];
+				for (let e of n) {
+					if (e.tenantId !== a.tenantId || e.queue !== i || e.state !== "matched" && e.state !== "assigned" || !e.matchedAt) continue;
+					let n = new Date(e.matchedAt).getTime(), o = new Date(e.createdAt).getTime();
+					if (Number.isFinite(n) && Number.isFinite(o) && n >= t && n >= o && r.push(n - o), r.length >= N) break;
+				}
+				if (r.length < 3) return {
+					queue: i,
+					waitMs: null,
+					samples: r.length
+				};
+				r.sort((e, t) => e - t);
+				let o = r.length >> 1;
+				return {
+					queue: i,
+					waitMs: r.length % 2 ? r[o] : Math.round((r[o - 1] + r[o]) / 2),
+					samples: r.length
+				};
+			});
+		}
+	}, Z = (e) => {
+		if (!r(e.tenantId) || !r(e.subjectId) || !["user", "guest"].includes(e.kind)) throw t("invalid_input");
+		return {
+			tenant: e.tenantId,
+			owner: e.subjectId
+		};
+	}, Q = async (e, n, r) => {
+		let i = await e.query(y(c).where(g(_("tenantId", n), _("subjectId", r))).orderBy("id", "asc").limit(R + 1).descriptor);
+		if (i.length > R) throw t("export_limit");
+		if (i.some((e) => e.tenantId !== n || e.subjectId !== r)) throw t("unavailable");
+		return i;
+	};
+	return {
+		service: X,
+		enqueueGroup: (a, o, s, d, p) => {
+			let S, A, j;
+			try {
+				if (S = k(a), !r(s) || !r(o.queue) || !r(o.requestId) || !o.preferences || typeof o.preferences != "object" || Array.isArray(o.preferences)) throw t("invalid_input");
+				let e = f.get(o.queue);
+				if (!e) throw t("not_found");
+				j = e, A = Object.freeze({
+					queue: o.queue,
+					requestId: o.requestId,
+					preferences: n(o.preferences, L)
+				});
+			} catch (e) {
+				return m.fail(C(e));
+			}
+			return m.gen(function* () {
+				let r = H(S.tenantId, S.id, "party:" + s + ":" + A.requestId), a = x([
+					A.queue,
+					A.preferences,
+					s
+				]), o = yield* Y(() => b(S, j, A.preferences)), f = yield* m.try({
+					try: () => {
+						if (!o || typeof o != "object" || Array.isArray(o)) throw t("invalid_input");
+						let e = n(o, j.maxAttributeBytes), r = h.decodeUnknownSync(j.ticket, { onExcessProperty: "error" })(e);
+						if (!i(e, r)) throw t("invalid_input");
+						return n(r, j.maxAttributeBytes);
+					},
+					catch: C
+				});
+				return yield* T(async () => {
+					let n = new Set(await p());
+					for (let e of n) await K(S.tenantId, e);
+					return await q(S.tenantId, A.queue), e.transactional(async (e) => {
+						let i = [...await d(e)].sort();
+						if (!i.includes(S.id) || i.some((e) => !n.has(e))) throw t("conflict");
+						let o = await W(e, S.tenantId, S.id, r);
+						if (o) {
+							if (o.requestKey !== a || o.queue !== A.queue) throw t("conflict");
+							return O(o);
+						}
+						let p = z(), h = [];
+						for (let n of i) {
+							let r = B(S.tenantId, n);
+							if (await e.updateMany(u.tableName, { admission: 0 }, { where: _("id", r) }) !== 1) throw t("unavailable");
+							let i = (await e.query(y(u).where(_("id", r)).limit(1).descriptor))[0];
+							if (!i || i.tenantId !== S.tenantId || i.subjectId !== n) throw t(w(i?.erased) ? "erased" : "unavailable");
+							if (i.activeTicketId !== null) {
+								let n = (await e.query(y(c).where(_("id", E(i, "activeTicketId"))).limit(1).descriptor))[0];
+								if (n && n.tenantId !== S.tenantId) throw t("unavailable");
+								if (n && n.state === "open" && D(n.expiresAt) > p) throw t("already_searching");
+								n && n.state === "open" && await e.update(c.tableName, E(n, "id"), {
+									state: "expired",
+									closedAt: new Date(p)
+								});
+							}
+							h.push(i);
+						}
+						let b = V(S.tenantId, A.queue);
+						if (await e.updateMany(l.tableName, { admission: 0 }, { where: _("id", b) }) !== 1) throw t("unavailable");
+						let x = await e.query(y(c).where(g(_("tenantId", S.tenantId), _("queue", A.queue), _("state", "open"), v("expiresAt", new Date(p)))).limit(j.maxTickets + 1).forUpdate().descriptor);
+						if (x.some((e) => e.tenantId !== S.tenantId || e.queue !== A.queue)) throw t("unavailable");
+						if (x.length >= j.maxTickets) throw t("queue_full");
+						if (await m.runPromise(Y(() => F(S, j, e))), p + j.ticketTtlMs > 864e13 || !Number.isSafeInteger(p + j.ticketTtlMs)) throw t("invalid_input");
+						let C = await e.insert(c.tableName, {
+							id: r,
+							tenantId: S.tenantId,
+							subjectId: S.id,
+							queue: A.queue,
+							requestKey: a,
+							partyId: s,
+							members: i,
+							attributes: f,
+							state: "open",
+							createdAt: new Date(p),
+							expiresAt: new Date(p + j.ticketTtlMs),
+							closedAt: null,
+							metadata: {}
+						});
+						for (let t of h) await e.update(u.tableName, E(t, "id"), { activeTicketId: r });
+						return O(C);
+					});
+				});
+			}).pipe(m.catchDefect(() => m.fail(t("unavailable"))));
+		},
+		director: p(e, {
+			queues: o.queues,
+			avoidPairs: o.avoidPairs,
+			now: I
+		}),
+		exportSubject: (e) => {
+			let t;
+			try {
+				t = Z(e);
+			} catch (e) {
+				return m.fail(C(e));
+			}
+			return T(() => J(t.tenant, t.owner, void 0, async (e) => ({
+				tickets: (await Q(e, t.tenant, t.owner)).map((e) => O(e)),
+				assignments: await d(e, t.tenant, t.owner, R)
+			}), !0));
+		},
+		eraseSubject: (e) => {
+			let t;
+			try {
+				t = Z(e);
+			} catch (e) {
+				return m.fail(C(e));
+			}
+			return T(() => J(t.tenant, t.owner, void 0, async (e, n) => {
+				let r = await Q(e, t.tenant, t.owner);
+				for (let t of r) await e.delete(c.tableName, E(t, "id"));
+				await e.deleteMany(s.tableName, { where: g(_("tenantId", t.tenant), _("subjectId", t.owner)) }), await e.update(u.tableName, E(n, "id"), {
+					subjectId: null,
+					activeTicketId: null,
+					erased: !0
+				});
+			}, !0));
+		}
+	};
+};
+export { F as dataStoreMatchmakingTickets, S as matchmakingSubjectKey, A as resolveTicketAdmissionOptions };

package/dist/strategies.d.ts

@@ -0,0 +1,97 @@
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+declare type AvoidPair = readonly [string, string];
+
+/** Ordered policies consume disjoint proposals, sharing the original branch budget. */
+export declare const composite: <A = Readonly<Record<string, unknown>>>(functions: ReadonlyArray<MatchFunction<A>>) => MatchFunction<A>;
+
+/** Empty policy for an app without a block provider. Automatic optional Social
+ * port binding is separate integration work; it is not inferred here. */
+export declare const defaultMatchmakingAvoidPairs: MatchmakingAvoidPairs;
+
+export declare const fifo: <A = Readonly<Record<string, unknown>>>() => MatchFunction<A>;
+
+declare type MatchFunction<A = Readonly<Record<string, unknown>>> = (input: MatchInput<A>) => MatchOutput<A>;
+
+declare interface MatchInput<A = Readonly<Record<string, unknown>>> {
+    readonly tickets: ReadonlyArray<MatchTicket<A>>;
+    readonly now: number;
+    readonly queue: MatchQueueRules;
+    readonly avoid: ReadonlyArray<AvoidPair>;
+}
+
+export declare interface MatchmakingAvoidContext {
+    readonly tenantId: string;
+    readonly queue: string;
+    readonly tickets: ReadonlyArray<MatchTicket>;
+    readonly maxPairs: number;
+    readonly query: DataStore['query'];
+}
+
+export declare type MatchmakingAvoidPairs = (context: MatchmakingAvoidContext) => Effect.Effect<ReadonlyArray<AvoidPair>, MatchmakingError>;
+
+declare class MatchmakingError extends MatchmakingError_base {
+}
+
+declare const MatchmakingError_base: Schema.Class<MatchmakingError, Schema.TaggedStruct<"MatchmakingError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_queue", "invalid_proposal", "unavailable", "identity_required", "not_found", "already_searching", "conflict", "queue_full", "erased", "export_limit", "forbidden", "party_full", "already_in_party", "party_not_ready"]>;
+}>, YieldableError>;
+
+declare interface MatchOutput<A = Readonly<Record<string, unknown>>> {
+    readonly proposals: ReadonlyArray<MatchProposal<A>>;
+    readonly leftover: ReadonlyArray<MatchTicket<A>>;
+    /** Deterministic branch inspections, not a runtime or throughput measurement. */
+    readonly searchNodes: number;
+    readonly exhausted: boolean;
+}
+
+declare interface MatchProposal<A = Readonly<Record<string, unknown>>> {
+    readonly teams: ReadonlyArray<ReadonlyArray<MatchTicket<A>>>;
+    readonly quality: number;
+}
+
+declare interface MatchQueueRules {
+    readonly name: string;
+    readonly teams: {
+        readonly count: number;
+        readonly size: number;
+    };
+    readonly maxTickets: number;
+    readonly maxSearchNodes: number;
+    readonly maxAvoidPairs: number;
+    readonly maxAttributeBytes: number;
+    readonly minQuality: {
+        readonly initial: number;
+        readonly after: ReadonlyArray<readonly [number, number]>;
+    };
+}
+
+declare interface MatchTicket<A = Readonly<Record<string, unknown>>> {
+    readonly id: string;
+    readonly tenantId: string;
+    readonly queue: string;
+    readonly members: ReadonlyArray<string>;
+    readonly createdAt: number;
+    readonly attributes: A;
+}
+
+export declare const regionLatency: (options: {
+    readonly latencyMaxMs: number;
+}) => <A extends Readonly<Record<string, unknown>>>(input: MatchInput<A>) => MatchOutput<A>;
+
+export declare const skillWindow: (options: SkillWindowOptions) => <A extends Readonly<Record<string, unknown>>>(input: MatchInput<A>) => MatchOutput<A>;
+
+export declare interface SkillWindowOptions {
+    readonly initialWindow: number;
+    readonly growPerSecond: number;
+    readonly maxWindow: number;
+    readonly latencyMaxMs?: number;
+}
+
+/** Reject custom slot fabrication, overlapping assignments and omitted leftovers. */
+export declare const validateMatchOutput: <A>(raw: MatchInput<A>, output: MatchOutput<A>) => MatchOutput<A>;
+
+export { }

package/dist/strategies.js

@@ -0,0 +1,140 @@
+import { matchmakingError as e } from "./errors.js";
+import { captureMatchInput as t, minimumQuality as n, sameJson as r } from "./contract.js";
+import { packCapturedTeams as i } from "./packing.js";
+import { defaultMatchmakingAvoidPairs as a } from "./avoidPairs.js";
+// src/strategies.ts
+var o = (e, t) => e.now - Math.min(...t.flat().map((e) => e.createdAt)), s = (r, a) => {
+	let s = t(r), c = [], l = s.tickets, u = 0, d = !1;
+	for (; l.length > 0;) {
+		if (u === s.queue.maxSearchNodes) {
+			d = !0;
+			break;
+		}
+		let t = {
+			...s,
+			tickets: l,
+			queue: {
+				...s.queue,
+				maxSearchNodes: s.queue.maxSearchNodes - u
+			}
+		}, r = 0, f = i(t, (t) => {
+			let i = a(s, t);
+			if (i === null) return !1;
+			if (!Number.isFinite(i) || i < 0 || i > 1) throw e("invalid_proposal");
+			return i < n(s.queue, o(s, t)) ? !1 : (r = i, !0);
+		});
+		if (u += f.searchNodes, f.teams === null) {
+			d = f.exhausted;
+			break;
+		}
+		c.push(Object.freeze({
+			teams: f.teams,
+			quality: r
+		}));
+		let p = new Set(f.teams.flat().map((e) => e.id));
+		l = Object.freeze(l.filter((e) => !p.has(e.id)));
+	}
+	return Object.freeze({
+		proposals: Object.freeze(c),
+		leftover: l,
+		searchNodes: u,
+		exhausted: d
+	});
+}, c = () => (e) => s(e, () => 1), l = (t, n) => {
+	let r = t.attributes?.[n];
+	if (typeof r != "number" || !Number.isFinite(r)) throw e("invalid_input");
+	return r;
+}, u = (t, n) => {
+	let r = t.flat(), i = r[0]?.attributes.region;
+	if (typeof i != "string" || !i.trim()) throw e("invalid_input");
+	let a = 0;
+	for (let t of r) {
+		let r = t.attributes.region, o = t.attributes.latencies;
+		if (typeof r != "string" || !r.trim() || !o || typeof o != "object" || Array.isArray(o)) throw e("invalid_input");
+		let s = o[r];
+		if (typeof s != "number" || !Number.isFinite(s) || s < 0) throw e("invalid_input");
+		if (r !== i || s > n) return null;
+		a = Math.max(a, s);
+	}
+	return a;
+}, d = (n) => {
+	if (!n || typeof n != "object") throw e("invalid_queue");
+	let r = n.initialWindow, i = n.growPerSecond, a = n.maxWindow, c = n.latencyMaxMs;
+	if (![
+		r,
+		i,
+		a
+	].every((e) => Number.isFinite(e) && e >= 0 && e <= 0xe8d4a51000) || r > a || c !== void 0 && (!Number.isFinite(c) || c < 0 || c > 6e4)) throw e("invalid_queue");
+	return (e) => {
+		let n = t(e);
+		return n.tickets.forEach((e) => l(e, "skill")), s(n, (e, t) => {
+			let n = t.flat().map((e) => l(e, "skill")), s = Math.max(...n) - Math.min(...n);
+			return s > Math.min(a, r + i * (o(e, t) / 1e3)) || c !== void 0 && u(t, c) === null ? null : a === 0 ? 1 : Math.max(0, 1 - s / a);
+		});
+	};
+}, f = (t) => {
+	if (!t || typeof t != "object") throw e("invalid_queue");
+	let n = t.latencyMaxMs;
+	if (!Number.isFinite(n) || n < 0 || n > 6e4) throw e("invalid_queue");
+	return (e) => s(e, (e, t) => {
+		let r = u(t, n);
+		return r === null ? null : n === 0 ? 1 : Math.max(0, 1 - r / n);
+	});
+}, p = (i, a) => {
+	let s = t(i), c = new Map(s.tickets.map((e) => [e.id, e])), l = /* @__PURE__ */ new Set();
+	if (!a || !Array.isArray(a.proposals) || a.proposals.length > s.tickets.length || !Array.isArray(a.leftover) || !Number.isSafeInteger(a.searchNodes) || a.searchNodes < 0 || a.searchNodes > s.queue.maxSearchNodes || typeof a.exhausted != "boolean") throw e("invalid_proposal");
+	let u = (t) => {
+		let n = c.get(t?.id);
+		if (!n || l.has(n.id) || !r(n, t)) throw e("invalid_proposal");
+		return l.add(n.id), n;
+	}, d = Array.from(a.proposals, (t) => {
+		if (!t || !Array.isArray(t.teams) || t.teams.length !== s.queue.teams.count || !Number.isFinite(t.quality) || t.quality < 0 || t.quality > 1) throw e("invalid_proposal");
+		let r = Array.from(t.teams, (t) => {
+			if (!Array.isArray(t) || t.length < 1 || t.length > s.queue.teams.size) throw e("invalid_proposal");
+			let n = Array.from(t, u);
+			if (n.reduce((e, t) => e + t.members.length, 0) !== s.queue.teams.size) throw e("invalid_proposal");
+			return Object.freeze(n);
+		}), i = new Set(r.flat().flatMap((e) => [...e.members]));
+		if (s.avoid.some(([e, t]) => i.has(e) && i.has(t)) || t.quality < n(s.queue, o(s, r))) throw e("invalid_proposal");
+		return Object.freeze({
+			teams: Object.freeze(r),
+			quality: t.quality
+		});
+	}), f = Array.from(a.leftover, u);
+	if (l.size !== s.tickets.length) throw e("invalid_proposal");
+	return f.sort((e, t) => e.createdAt - t.createdAt || (e.id < t.id ? -1 : +(e.id > t.id))), Object.freeze({
+		proposals: Object.freeze(d),
+		leftover: Object.freeze(f),
+		searchNodes: a.searchNodes,
+		exhausted: a.exhausted
+	});
+}, m = (n) => {
+	if (!Array.isArray(n) || n.length < 1 || n.length > 32 || n.some((e) => typeof e != "function")) throw e("invalid_queue");
+	let r = Object.freeze([...n]);
+	return (e) => {
+		let n = t(e), i = [], a = n.tickets, o = 0, s = !1;
+		for (let e of r) {
+			if (a.length === 0) break;
+			if (o === n.queue.maxSearchNodes) {
+				s = !0;
+				break;
+			}
+			let t = Object.freeze({
+				...n,
+				tickets: a,
+				queue: Object.freeze({
+					...n.queue,
+					maxSearchNodes: n.queue.maxSearchNodes - o
+				})
+			}), r = p(t, e(t));
+			i.push(...r.proposals), a = r.leftover, o += r.searchNodes, s ||= r.exhausted;
+		}
+		return Object.freeze({
+			proposals: Object.freeze(i),
+			leftover: a,
+			searchNodes: o,
+			exhausted: s
+		});
+	};
+};
+export { m as composite, a as defaultMatchmakingAvoidPairs, c as fifo, f as regionLatency, d as skillWindow, p as validateMatchOutput };