@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/quests.d.ts

@@ -0,0 +1,142 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare const captureQuestSignal: (input: unknown) => QuestSignal;
+
+export declare const defaultQuestProgressResolver: QuestProgressResolver;
+
+/** Deterministic weighted selection without replacement; a trusted seed is not a security RNG. */
+export declare const defaultQuestSelector: QuestSelector;
+
+export declare const defineQuest: (input: QuestDefinition) => QuestDefinition;
+
+export declare const defineQuestPool: (input: QuestPoolDefinition) => QuestPool;
+
+declare class ProgressionError extends ProgressionError_base {
+}
+
+declare const ProgressionError_base: Schema.Class<ProgressionError, Schema.TaggedStruct<"ProgressionError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_curve", "invalid_reward", "invalid_track", "invalid_stat", "overflow", "insufficient_resource", "forbidden", "conflict", "erased", "not_found", "limit_exceeded", "unavailable"]>;
+}>, YieldableError>;
+
+declare type ProgressionReward = {
+    readonly kind: 'currency';
+    readonly currency: string;
+    readonly amount: string;
+} | {
+    readonly kind: 'item';
+    readonly itemId: string;
+    readonly qty: number;
+} | {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly amount: string;
+};
+
+declare type ProgressValue = string | number | bigint;
+
+export declare interface QuestDefinition {
+    readonly id: string;
+    readonly titleKey?: string;
+    readonly objectives: readonly QuestObjective[];
+    readonly reward: readonly ProgressionReward[];
+}
+
+export declare const questFields: (input: unknown) => Readonly<Record<string, QuestScalar>>;
+
+export declare type QuestObjective = {
+    readonly stat: string;
+    readonly target: number;
+} | {
+    readonly event: string;
+    readonly target: number;
+    readonly where?: Readonly<Record<string, QuestScalar>>;
+};
+
+export declare interface QuestPool extends QuestPoolDefinition {
+    readonly version: number;
+    readonly rerolls: number;
+    readonly weights: Readonly<Record<string, number>>;
+}
+
+export declare interface QuestPoolDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly slots: number;
+    readonly rerolls?: number;
+    readonly refresh: {
+        readonly cron: string;
+        readonly timezone: string;
+    };
+    readonly quests: readonly QuestDefinition[];
+    readonly weights?: Readonly<Record<string, number>>;
+}
+
+export declare interface QuestProgressContext {
+    readonly quest: QuestDefinition;
+    readonly progress: readonly number[];
+    readonly signal: QuestSignal;
+}
+
+export declare type QuestProgressResolver = (context: QuestProgressContext) => readonly number[];
+
+export declare type QuestScalar = string | number | boolean | null;
+
+export declare type QuestSelector = (context: QuestSelectorContext) => readonly string[];
+
+export declare interface QuestSelectorContext {
+    readonly pool: QuestPool;
+    readonly count: number;
+    readonly seed: number;
+    readonly excluded: readonly string[];
+}
+
+export declare type QuestSignal = {
+    readonly kind: 'stat';
+    readonly stat: string;
+    readonly delta: string;
+} | {
+    readonly kind: 'event';
+    readonly event: string;
+    readonly data: Readonly<Record<string, QuestScalar>>;
+};
+
+export declare type QuestSignalInput = {
+    readonly kind: 'stat';
+    readonly stat: string;
+    readonly delta: ProgressValue;
+} | {
+    readonly kind: 'event';
+    readonly event: string;
+    readonly data?: Readonly<Record<string, QuestScalar>>;
+};
+
+export declare class QuestSource extends QuestSource_base {
+}
+
+declare const QuestSource_base: Context.ServiceClass<QuestSource, "@voltro/QuestSource", QuestSourceService>;
+
+export declare interface QuestSourceScope {
+    readonly tenantId: string;
+    readonly channel: string;
+    readonly locale: string;
+}
+
+export declare interface QuestSourceService {
+    readonly read: (scope: QuestSourceScope) => Effect.Effect<{
+        readonly revision: string;
+        readonly pools: readonly QuestPool[];
+    }, ProgressionError>;
+}
+
+export declare const questTimezone: (input: unknown) => string;
+
+export declare const resolveQuestProgress: (input: QuestProgressContext, slot?: QuestProgressResolver) => readonly number[];
+
+export declare const selectQuests: (input: QuestSelectorContext, slot?: QuestSelector) => readonly string[];
+
+export declare const staticQuestSource: (input: readonly QuestPoolDefinition[], revision?: string) => QuestSourceService;
+
+export { }

package/dist/quests.js

@@ -0,0 +1,152 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, list as r, object as i, progressValue as a } from "./capture.js";
+import { captureRewards as o } from "./reward.js";
+import { Context as s, Cron as c, Effect as l } from "effect";
+// src/quests.ts
+var u = (n) => {
+	let r = i(n), a = Object.entries(r);
+	if (a.length > 32) throw e("invalid_input");
+	return Object.freeze(Object.fromEntries(a.map(([n, r]) => {
+		if (t(n), r !== null && typeof r != "boolean" && !(typeof r == "string" && r.length <= 256) && (typeof r != "number" || !Number.isFinite(r) || Object.is(r, -0))) throw e("invalid_input");
+		return [n, r];
+	})));
+}, d = (t) => {
+	if (typeof t != "string" || t.length < 1 || t.length > 64) throw e("invalid_input");
+	try {
+		new Intl.DateTimeFormat("en", { timeZone: t }).format(0);
+	} catch {
+		throw e("invalid_input");
+	}
+	return t;
+}, f = (a) => {
+	let s = i(a, [
+		"id",
+		"titleKey",
+		"objectives",
+		"reward"
+	]), c = Object.freeze(r(s.objectives, 16).map((r) => {
+		let a = i(r, [
+			"stat",
+			"event",
+			"where",
+			"target"
+		]), o = n(a.target, 1, 1e6);
+		if (a.stat !== void 0 && a.event === void 0 && a.where === void 0) return Object.freeze({
+			stat: t(a.stat),
+			target: o
+		});
+		if (a.event !== void 0 && a.stat === void 0) return Object.freeze({
+			event: t(a.event),
+			target: o,
+			...a.where === void 0 ? {} : { where: u(a.where) }
+		});
+		throw e("invalid_input");
+	}));
+	if (c.length === 0) throw e("invalid_input");
+	return Object.freeze({
+		id: t(s.id),
+		...s.titleKey === void 0 ? {} : { titleKey: t(s.titleKey) },
+		objectives: c,
+		reward: o(s.reward, 64)
+	});
+}, p = (a) => {
+	let o = i(a, [
+		"id",
+		"version",
+		"slots",
+		"rerolls",
+		"refresh",
+		"quests",
+		"weights"
+	]), s = i(o.refresh, ["cron", "timezone"]), l = Object.freeze(r(o.quests, 128).map((e) => f(e))), u = n(o.slots, 1, 8);
+	if (l.length < u || new Set(l.map((e) => e.id)).size !== l.length || typeof s.cron != "string" || s.cron.length < 1 || s.cron.length > 120 || /[\r\n]/.test(s.cron)) throw e("invalid_input");
+	let p = s.timezone === "player" ? "player" : d(s.timezone);
+	if (c.parse(s.cron, p === "player" ? "UTC" : p)._tag === "Failure") throw e("invalid_input");
+	let m = i(o.weights ?? {});
+	if (Object.keys(m).some((e) => !l.some((t) => t.id === e))) throw e("invalid_input");
+	let h = Object.freeze(Object.fromEntries(l.map((e) => [e.id, n(m[e.id] ?? 1, 1, 1e6)])));
+	return Object.freeze({
+		id: t(o.id),
+		version: n(o.version ?? 1, 1, 1e6),
+		slots: u,
+		rerolls: n(o.rerolls ?? 0, 0, 8),
+		refresh: Object.freeze({
+			cron: s.cron,
+			timezone: p
+		}),
+		quests: l,
+		weights: h
+	});
+}, m = ({ pool: t, count: n, seed: r, excluded: i }) => {
+	let a = r >>> 0, o = t.quests.filter((e) => !i.includes(e.id)), s = [];
+	for (let r = 0; r < n; r++) {
+		if (o.length === 0) throw e("not_found");
+		a = Math.imul(a, 1664525) + 1013904223 >>> 0;
+		let n = o.reduce((e, n) => e + t.weights[n.id], 0), r = a / 4294967296 * n, i = 0;
+		for (; i < o.length - 1 && (r -= t.weights[o[i].id], !(r < 0)); i++);
+		s.push(o.splice(i, 1)[0].id);
+	}
+	return Object.freeze(s);
+}, h = (i, a = m) => {
+	let o = p(i.pool), s = n(i.count, 1, o.slots), c = n(i.seed, 0, 4294967295), l = Object.freeze(r(i.excluded, 128).map(t));
+	if (new Set(l).size !== l.length || l.some((e) => !o.quests.some((t) => t.id === e))) throw e("invalid_input");
+	let u = Object.freeze(r(a(Object.freeze({
+		pool: o,
+		count: s,
+		seed: c,
+		excluded: l
+	})), s).map(t));
+	if (u.length !== s || new Set(u).size !== u.length || u.some((e) => l.includes(e) || !o.quests.some((t) => t.id === e))) throw e("invalid_input");
+	return u;
+}, g = (n) => {
+	let r = i(n, [
+		"kind",
+		"stat",
+		"delta",
+		"event",
+		"data"
+	]);
+	if (r.kind === "stat" && r.event === void 0 && r.data === void 0) return Object.freeze({
+		kind: "stat",
+		stat: t(r.stat),
+		delta: String(a(r.delta))
+	});
+	if (r.kind === "event" && r.stat === void 0 && r.delta === void 0) return Object.freeze({
+		kind: "event",
+		event: t(r.event),
+		data: u(r.data ?? {})
+	});
+	throw e("invalid_input");
+}, _ = ({ quest: e, progress: t, signal: n }) => Object.freeze(e.objectives.map((e, r) => {
+	let i = t[r];
+	return "stat" in e && n.kind === "stat" && e.stat === n.stat ? Number(BigInt(i) + BigInt(n.delta) > BigInt(e.target) ? BigInt(e.target) : BigInt(i) + BigInt(n.delta)) : "event" in e && n.kind === "event" && e.event === n.event && Object.entries(e.where ?? {}).every(([e, t]) => Object.hasOwn(n.data, e) && n.data[e] === t) ? Math.min(e.target, i + 1) : i;
+})), v = (t, i = _) => {
+	let a = f(t.quest), o = g(t.signal), s = Object.freeze(r(t.progress, 16).map((e, t) => n(e, 0, a.objectives[t]?.target ?? -1)));
+	if (s.length !== a.objectives.length) throw e("invalid_record");
+	let c = Object.freeze(r(i(Object.freeze({
+		quest: a,
+		signal: o,
+		progress: s
+	})), 16).map((e, t) => n(e, s[t] ?? 0, a.objectives[t]?.target ?? -1)));
+	if (c.length !== s.length) throw e("invalid_input");
+	return c;
+}, y = class extends s.Service()("@voltro/QuestSource") {}, b = (n, a = "static.v1") => {
+	let o = Object.freeze(r(n, 64).map((e) => p(e))), s = t(a);
+	if (new Set(o.map((e) => e.id)).size !== o.length) throw e("invalid_input");
+	return Object.freeze({ read: (n) => {
+		try {
+			let e = i(n, [
+				"tenantId",
+				"channel",
+				"locale"
+			]);
+			return t(e.tenantId), t(e.channel), t(e.locale), l.succeed(Object.freeze({
+				revision: s,
+				pools: o
+			}));
+		} catch {
+			return l.fail(e("invalid_input"));
+		}
+	} });
+};
+export { y as QuestSource, g as captureQuestSignal, _ as defaultQuestProgressResolver, m as defaultQuestSelector, f as defineQuest, p as defineQuestPool, u as questFields, d as questTimezone, v as resolveQuestProgress, h as selectQuests, b as staticQuestSource };

package/dist/rank-app/schedules/progression.dispatchRankClosures.cron.tsx

@@ -0,0 +1,19 @@
+import { Effect } from 'effect'
+import { defineSchedule } from '@voltro/runtime'
+import { systemSubject } from '@voltro/protocol'
+import { RankClosurePort } from '@voltro/plugin-progression/rank-seasons/closure'
+import { ProgressionError } from '@voltro/plugin-progression/errors'
+export default defineSchedule({ name: 'progression.dispatchRankClosures', cron: '* * * * *', timezone: 'UTC', handler: ctx => Effect.gen(function* () {
+  const service = yield* RankClosurePort, workflows = ctx.app.workflows
+  const failure = () => new ProgressionError({ code: 'unavailable' })
+  if (!workflows) return yield* Effect.fail(failure())
+  let after: string | undefined, failed = false
+  for (let page = 0; page < 100; page++) {
+    const batch = yield* service.dispatch(systemSubject('progression.rank.dispatch'), { limit: 100, ...(after ? { after } : {}) }, payload => Effect.tryPromise(() => workflows.start('progression.closeRankSeason', payload)))
+    failed ||= batch.failed.length > 0
+    if (batch.next === null) { if (failed) return yield* Effect.fail(failure()); return }
+    after = batch.next
+  }
+  // Accepted SQL units remain due. Exhausting the bounded scan makes the schedule red.
+  return yield* Effect.fail(failure())
+}) })

package/dist/rank-app/workflows/progression.closeRankSeason.workflow.server.tsx

@@ -0,0 +1,10 @@
+import { Effect } from 'effect'
+import { step } from '@voltro/workflow'
+import { systemSubject } from '@voltro/protocol'
+import { RankClosurePort, RankClosureReceiptSchema, type RankClosureRequest } from '@voltro/plugin-progression/rank-seasons/closure'
+import { ProgressionError } from '@voltro/plugin-progression/errors'
+export default () => (payload: RankClosureRequest) => Effect.gen(function* () {
+  const service = yield* RankClosurePort
+  return yield* step({ name: 'close-accepted-rank-season', success: RankClosureReceiptSchema, error: ProgressionError,
+    retry: { maxAttempts: 5 }, execute: service.execute(systemSubject('progression.rank.workflow'), payload) })
+})

package/dist/rank-app/workflows/progression.closeRankSeason.workflow.tsx

@@ -0,0 +1 @@
+export { ProgressionRankClosure } from '@voltro/plugin-progression/rank-seasons/workflow'

package/dist/rankClosure.d.ts

@@ -0,0 +1,69 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { WorkflowRunHandle } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const captureRankClosureReceipt: (input: unknown) => RankClosureReceipt;
+
+declare class ProgressionError extends ProgressionError_base {
+}
+
+declare const ProgressionError_base: Schema.Class<ProgressionError, Schema.TaggedStruct<"ProgressionError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_curve", "invalid_reward", "invalid_track", "invalid_stat", "overflow", "insufficient_resource", "forbidden", "conflict", "erased", "not_found", "limit_exceeded", "unavailable"]>;
+}>, YieldableError>;
+
+export declare interface RankClosureDispatchInput {
+    readonly limit?: number;
+    readonly after?: string;
+}
+
+export declare interface RankClosureDispatchResult {
+    readonly scanned: number;
+    readonly admitted: number;
+    readonly failed: readonly string[];
+    readonly next: string | null;
+}
+
+export declare interface RankClosureOptions {
+    readonly service?: RankClosureService | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+}
+
+export declare class RankClosurePort extends RankClosurePort_base {
+}
+
+declare const RankClosurePort_base: Context.ServiceClass<RankClosurePort, "@voltro/RankClosurePort", RankClosureService>;
+
+export declare interface RankClosureReceipt {
+    readonly unitId: string;
+    readonly status: 'closed' | 'erased';
+    readonly operationId: string | null;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+export declare const RankClosureReceiptSchema: Schema.Struct<{
+    readonly unitId: Schema.String;
+    readonly status: Schema.Literals<readonly ["closed", "erased"]>;
+    readonly operationId: Schema.NullOr<Schema.String>;
+    readonly rewardsQueued: Schema.Number;
+    readonly at: Schema.Number;
+}>;
+
+export declare interface RankClosureRequest {
+    readonly unitId: string;
+}
+
+export declare const RankClosureRequestSchema: Schema.Struct<{
+    readonly unitId: Schema.String;
+}>;
+
+export declare interface RankClosureService {
+    readonly execute: (subject: Subject, input: RankClosureRequest) => Effect.Effect<RankClosureReceipt, ProgressionError>;
+    readonly dispatch: (subject: Subject, input: RankClosureDispatchInput, start: (payload: RankClosureRequest) => Effect.Effect<WorkflowRunHandle, unknown>) => Effect.Effect<RankClosureDispatchResult, ProgressionError>;
+}
+
+export { }

package/dist/rankClosure.js

@@ -0,0 +1,34 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, object as r } from "./capture.js";
+import { Context as i, Schema as a } from "effect";
+// src/rankClosure.ts
+var o = a.String.pipe(a.check(a.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/))), s = a.Struct({ unitId: o }), c = a.Struct({
+	unitId: o,
+	status: a.Literals(["closed", "erased"]),
+	operationId: a.NullOr(o),
+	rewardsQueued: a.Number.pipe(a.check(a.isInt()), a.check(a.isBetween({
+		minimum: 0,
+		maximum: 64
+	}))),
+	at: a.Number.pipe(a.check(a.isInt()), a.check(a.isBetween({
+		minimum: 0,
+		maximum: 864e13
+	})))
+}), l = (i) => {
+	let a = r(i, [
+		"unitId",
+		"status",
+		"operationId",
+		"rewardsQueued",
+		"at"
+	]), o = t(a.unitId), s = n(a.at, 0, 864e13), c = n(a.rewardsQueued, 0, 64);
+	if (a.status !== "closed" && a.status !== "erased" || a.status === "erased" && (a.operationId !== null || c !== 0) || a.status === "closed" && a.operationId === null) throw e("invalid_record");
+	return Object.freeze({
+		unitId: o,
+		status: a.status,
+		operationId: a.operationId === null ? null : t(a.operationId),
+		rewardsQueued: c,
+		at: s
+	});
+}, u = class extends i.Service()("@voltro/RankClosurePort") {};
+export { u as RankClosurePort, c as RankClosureReceiptSchema, s as RankClosureRequestSchema, l as captureRankClosureReceipt };

package/dist/rankClosure.server.js

@@ -0,0 +1,138 @@
+import { ProgressionError as e, progressionError as t } from "./errors.js";
+import { captureArguments as n, identifier as r, integer as i, list as a, object as o } from "./capture.js";
+import { captureRankClosureReceipt as s } from "./rankClosure.js";
+import { questHash as c } from "./questStore.js";
+import { rankClosureUnitsTable as l } from "./rankTables.entity.js";
+import { resolveRankStoreOptions as u } from "./rankStore.js";
+import { Effect as d, Result as f, Schema as p } from "effect";
+import { WorkflowRunHandleSchema as m } from "@voltro/protocol";
+import { and as h, eq as g, gt as _, lte as v, queryFor as y } from "@voltro/database";
+// src/rankClosure.server.ts
+var b = (e = {}) => {
+	let n = o(e, [
+		"service",
+		"now",
+		"allowedServices"
+	]), i = Object.freeze(a(n.allowedServices ?? [], 256).map(r)), s = n.now ?? Date.now;
+	if (typeof s != "function" || new Set(i).size !== i.length) throw t("invalid_input");
+	let c = n.service === void 0 ? void 0 : o(n.service);
+	if (c && (typeof c.execute != "function" || typeof c.dispatch != "function")) throw t("invalid_input");
+	let l = c ? Object.freeze({
+		execute: c.execute.bind(n.service),
+		dispatch: c.dispatch.bind(n.service)
+	}) : void 0;
+	return Object.freeze({
+		service: l,
+		now: s,
+		allowedServices: i
+	});
+}, x = (e, ...t) => e + c(t).slice(0, 56), S = (e) => i(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN, 0, 864e13), C = (n) => d.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), w = (a, w, T, E = {}) => {
+	let D = u(T), O = b(E), k = new Map(D.seasons.map((e) => [e.id, e])), A = new Set(O.allowedServices);
+	if (O.service) throw t("invalid_input");
+	let j = (e) => {
+		if (e.type !== "system" && !(e.type === "service" && A.has(e.service))) throw t("forbidden");
+	}, M = async (e) => {
+		let n = (await a.query(y(l).where(g("id", e)).limit(1).descriptor))[0];
+		if (!n) throw t("not_found");
+		let o = r(n.stateId);
+		if (n.id !== e || e !== x("prc_", o)) throw t("invalid_record");
+		if (r(n.tenantId), r(n.seasonId), i(n.version, 1, 1e6), S(n.until), S(n.createdAt), n.state === "erased") {
+			if (n.ownerId !== null || n.ownerKey !== null || n.receipt !== null) throw t("invalid_record");
+			return n;
+		}
+		let c = r(n.tenantId), u = r(n.ownerId), d = k.get(r(n.seasonId));
+		if (!d || d.version !== n.version || d.until !== S(n.until)) throw t("conflict");
+		if (o !== x("prv_", c, u, d.id, String(d.version)) || n.ownerKey !== x("prs_", c, u) || n.state !== "open" && n.state !== "closed" || n.state === "open" && n.receipt !== null) throw t("invalid_record");
+		if (n.state === "closed") {
+			let r = s(n.receipt);
+			if (r.unitId !== e || r.status !== "closed" || r.at < d.until || r.at < S(n.createdAt)) throw t("invalid_record");
+		}
+		return n;
+	}, N = async (e, n) => {
+		if (n.state === "erased") return s({
+			unitId: n.id,
+			status: "erased",
+			operationId: null,
+			rewardsQueued: 0,
+			at: S(n.createdAt)
+		});
+		if (n.state !== "closed") return;
+		let i = await d.runPromise(d.result(w.auditRanks(e, r(n.tenantId), r(n.ownerId))));
+		if (f.isFailure(i)) {
+			if (i.failure.code === "erased") {
+				let t = await M(r(n.id));
+				if (t.state === "erased") return N(e, t);
+			}
+			throw i.failure;
+		}
+		if (!i.success.matches) throw t("invalid_record");
+		let a = await M(r(n.id));
+		if (a.state === "erased") return N(e, a);
+		if (a.state !== "closed" || c(a.receipt) !== c(n.receipt)) throw t("conflict");
+		return s(a.receipt);
+	};
+	return Object.freeze({
+		execute: (i, a) => {
+			try {
+				let e = n(i);
+				j(e);
+				let s = o(a, ["unitId"]), c = r(s.unitId);
+				return C(async () => {
+					let n = await M(c), i = await N(e, n);
+					if (i) return i;
+					let a = await d.runPromise(d.result(w.close(e, {
+						tenantId: r(n.tenantId),
+						ownerId: r(n.ownerId),
+						seasonId: r(n.seasonId),
+						requestId: "rank.close:" + c
+					})));
+					if (f.isFailure(a)) {
+						if (a.failure.code === "erased") {
+							let t = await M(c), n = await N(e, t);
+							if (n?.status === "erased") return n;
+						}
+						throw a.failure;
+					}
+					let o = await N(e, await M(c));
+					if (!o || o.status === "closed" && (o.operationId !== a.success.operationId || o.rewardsQueued !== a.success.rewardsQueued || o.at !== a.success.at)) throw t("invalid_record");
+					return o;
+				});
+			} catch (n) {
+				return d.fail(n instanceof e ? n : t("invalid_input"));
+			}
+		},
+		dispatch: (s, c, u) => {
+			try {
+				let e = n(s);
+				j(e);
+				let f = o(c, ["limit", "after"]), b = i(f.limit ?? 100, 1, 1e3), x = f.after === void 0 ? void 0 : r(f.after);
+				if (typeof u != "function") throw t("invalid_input");
+				return C(async () => {
+					let e = i(O.now(), 0, 864e13), o = h(g("state", "open"), v("until", new Date(e))), s = x ? h(o, _("id", x)) : o, c = await a.query(y(l).where(s).orderBy("id", "asc").select("id").limit(b + 1).descriptor), f = c.slice(0, b), S = [], C = 0;
+					for (let e of f) {
+						let i = r(e.id);
+						try {
+							let e = p.decodeUnknownSync(m, { onExcessProperty: "error" })(n(await d.runPromise(u(Object.freeze({ unitId: i })))));
+							if (e.workflowName !== "progression.closeRankSeason" || !e.id.trim() || e.status === "dropped" || e.status !== "queued" && (e.executionId === null || !e.executionId.trim())) throw t("invalid_record");
+							C++;
+						} catch {
+							S.push(i);
+						}
+					}
+					return Object.freeze({
+						scanned: f.length,
+						admitted: C,
+						failed: Object.freeze(S),
+						next: c.length > b ? r(f.at(-1).id) : null
+					});
+				});
+			} catch (n) {
+				return d.fail(n instanceof e ? n : t("invalid_input"));
+			}
+		}
+	});
+};
+export { w as dataStoreRankClosure, b as resolveRankClosureOptions };

package/dist/rankClosureWorkflow.d.ts

@@ -0,0 +1,34 @@
+import { Literals } from 'effect/Schema';
+import { NullOr } from 'effect/Schema';
+import { Number as Number_2 } from 'effect/Schema';
+import { Schema } from 'effect';
+import { String as String_2 } from 'effect/Schema';
+import { Struct } from 'effect/Schema';
+import { Workflow } from 'effect/workflow/Workflow';
+import { WorkflowMessagesCarrier } from '@voltro/workflow';
+import { YieldableError } from 'effect/Cause';
+
+declare class ProgressionError extends ProgressionError_base {
+}
+
+declare const ProgressionError_base: Schema.Class<ProgressionError, Schema.TaggedStruct<"ProgressionError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_curve", "invalid_reward", "invalid_track", "invalid_stat", "overflow", "insufficient_resource", "forbidden", "conflict", "erased", "not_found", "limit_exceeded", "unavailable"]>;
+}>, YieldableError>;
+
+/** Only accepted opaque SQL unit identities enter the durable workflow journal. */
+export declare const ProgressionRankClosure: Workflow<"progression.closeRankSeason", Struct<{
+    readonly unitId: String_2;
+}>, Struct<{
+    readonly unitId: String_2;
+    readonly status: Literals<readonly ["closed", "erased"]>;
+    readonly operationId: NullOr<String_2>;
+    readonly rewardsQueued: Number_2;
+    readonly at: Number_2;
+}>, typeof ProgressionError> & {
+    readonly name: "progression.closeRankSeason";
+} & WorkflowMessagesCarrier<{
+    readonly signals: {};
+    readonly updates: {};
+}>;
+
+export { }

package/dist/rankClosureWorkflow.js

@@ -0,0 +1,15 @@
+import { ProgressionError as e } from "./errors.js";
+import { RankClosureReceiptSchema as t, RankClosureRequestSchema as n } from "./rankClosure.js";
+import { workflow as r } from "@voltro/workflow/define";
+// src/rankClosureWorkflow.ts
+var i = r({
+	name: "progression.closeRankSeason",
+	payload: n,
+	success: t,
+	error: e,
+	idempotencyKey: ({ unitId: e }) => `progression.rank.close:${e}`,
+	concurrency: { limit: 4 },
+	suspendOnFailure: !0,
+	internal: !0
+});
+export { i as ProgressionRankClosure };

package/dist/rankReader.server.js

@@ -0,0 +1,56 @@
+import { progressionError as e } from "./errors.js";
+import { captureArguments as t, identifier as n, integer as r, list as i, object as a } from "./capture.js";
+import { captureRankRating as o, defineRankLadder as s, resolveRank as c, resolveRankStrategies as l } from "./ranks.js";
+import { Effect as u } from "effect";
+// src/rankReader.server.ts
+var d = (t) => {
+	let n = a(t);
+	if (typeof n.myRating != "function") throw e("invalid_input");
+	let r = n.myRating;
+	return Object.freeze({ read: (n, i) => u.try({
+		try: () => r.call(t, n, i),
+		catch: () => e("unavailable")
+	}).pipe(u.flatten, u.mapError(() => e("unavailable")), u.flatMap((t) => u.try({
+		try: () => o(t, i),
+		catch: () => e("invalid_record")
+	}))) });
+}, f = (d) => {
+	let f = a(d, [
+		"ladders",
+		"source",
+		"strategies",
+		"now"
+	]), p = Object.freeze(i(f.ladders, 64).map((e) => s(e))), m = a(f.source), h = f.now ?? Date.now, g = l(f.strategies);
+	if (!p.length || new Set(p.map((e) => e.id)).size !== p.length || typeof m.read != "function" || typeof h != "function") throw e("invalid_input");
+	let _ = m.read, v = h;
+	return Object.freeze({ mine: (i) => {
+		try {
+			let a = t(i);
+			if (a.type !== "user") throw e("forbidden");
+			return n(a.id), n(a.tenantId), u.gen(function* () {
+				let t = /* @__PURE__ */ new Map();
+				for (let n of p) t.has(n.rating) || t.set(n.rating, yield* u.flatMap(u.try({
+					try: () => _.call(m, a, n.rating),
+					catch: () => e("unavailable")
+				}).pipe(u.flatten), (t) => u.try({
+					try: () => o(t, n.rating),
+					catch: () => e("invalid_record")
+				})));
+				return yield* u.try({
+					try: () => {
+						let e = r(v(), 0, 864e13);
+						return Object.freeze(p.map((n) => c({
+							ladder: n,
+							rating: t.get(n.rating),
+							at: e
+						}, g)));
+					},
+					catch: () => e("invalid_record")
+				});
+			});
+		} catch {
+			return u.fail(e("forbidden"));
+		}
+	} });
+};
+export { f as makeRankReader, d as ratingSourceFromLeaderboards };