@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/questComponents.js

@@ -0,0 +1,162 @@
+import { PlayerQuestSchema as e } from "./rpc.js";
+import { useQuestReroll as t, useQuests as n } from "./web.js";
+import { browserQuestRerollJournal as r } from "./questRerollJournal.js";
+import { Schema as i } from "effect";
+import { useEffect as a, useId as o, useRef as s, useState as c } from "react";
+import { useUiStrings as l } from "@voltro/ui";
+import { jsx as u, jsxs as d } from "react/jsx-runtime";
+// src/questComponents.tsx
+function f({ quest: e, now: t, title: n, locale: r, pending: i = !1, blocked: a = !1, error: f = !1, onReroll: p }) {
+	let m = l().quests, h = o(), g = s(!1), [_, v] = c(!1), y = e.expiresAt <= t, b = !y && e.state === "active" && e.rerollsUsed < e.rerollsAllowed && p !== void 0;
+	return /* @__PURE__ */ d("article", {
+		"data-quest": e.id,
+		"data-state": y ? "expired" : e.state,
+		"aria-labelledby": h,
+		"aria-busy": i,
+		children: [
+			/* @__PURE__ */ d("header", { children: [/* @__PURE__ */ u("h3", {
+				id: h,
+				children: n ?? e.quest.titleKey ?? e.quest.id
+			}), /* @__PURE__ */ u("p", {
+				"data-quest-state": !0,
+				children: y ? m.expired : e.state === "completed" ? m.completed : m.active
+			})] }),
+			/* @__PURE__ */ u("ul", {
+				"data-quest-objectives": !0,
+				children: e.quest.objectives.map((t, n) => {
+					let r = "stat" in t ? t.stat : t.event, i = e.progress[n] ?? 0;
+					return /* @__PURE__ */ d("li", { children: [/* @__PURE__ */ u("span", { children: m.objective(r, i, t.target) }), /* @__PURE__ */ u("progress", {
+						"aria-label": r,
+						value: i,
+						max: t.target
+					})] }, n);
+				})
+			}),
+			/* @__PURE__ */ u("p", { children: /* @__PURE__ */ u("time", {
+				dateTime: new Date(e.expiresAt).toISOString(),
+				children: m.expires(new Date(e.expiresAt).toLocaleString(r))
+			}) }),
+			p ? /* @__PURE__ */ d("div", {
+				"data-quest-reroll": !0,
+				children: [
+					/* @__PURE__ */ u("p", { children: m.remaining(Math.max(0, e.rerollsAllowed - e.rerollsUsed)) }),
+					/* @__PURE__ */ u("button", {
+						type: "button",
+						"aria-disabled": !b || i || a,
+						onClick: () => {
+							!b || i || a || g.current || (g.current = !0, v(!1), Promise.resolve().then(p).catch(() => {
+								v(!0);
+							}).finally(() => {
+								g.current = !1;
+							}));
+						},
+						children: i ? m.rerollPending : m.reroll
+					}),
+					f || _ ? /* @__PURE__ */ u("p", {
+						role: "alert",
+						children: m.rerollError
+					}) : null
+				]
+			}) : null
+		]
+	});
+}
+var p = i.decodeUnknownSync(i.Array(e), { onExcessProperty: "error" }), m = (e) => {
+	try {
+		if (!Array.isArray(e) || e.length > 512) return;
+		let t = p(e);
+		return t.length > 512 || new Set(t.map((e) => e.id)).size !== t.length || t.some((e) => !Number.isSafeInteger(e.assignedAt) || !Number.isSafeInteger(e.expiresAt) || e.assignedAt < 0 || e.expiresAt <= e.assignedAt || e.expiresAt > 864e13 || !Number.isInteger(e.rerollsUsed) || !Number.isInteger(e.rerollsAllowed) || e.rerollsUsed < 0 || e.rerollsUsed > e.rerollsAllowed || e.rerollsAllowed > 8 || e.quest.objectives.length < 1 || e.quest.objectives.length > 16 || e.progress.length !== e.quest.objectives.length || e.quest.objectives.some((t, n) => !Number.isSafeInteger(t.target) || t.target < 1 || t.target > 1e6 || !Number.isSafeInteger(e.progress[n]) || e.progress[n] < 0 || e.progress[n] > t.target) || e.state === "completed" && !e.progress.every((t, n) => t === e.quest.objectives[n].target)) ? void 0 : t;
+	} catch {
+		return;
+	}
+};
+function h({ api: e = "app", invocationScope: i, locale: o, journal: p = r, renderTitle: h }) {
+	let g = l().quests, _ = n(e), v = t(e), [y, b] = c(() => Date.now()), [x, S] = c(), [C, w] = c(), T = s(!1), E = s(!1), [D, O] = c(!1), [k, A] = c(!1), [j, M] = c(!1);
+	a(() => {
+		try {
+			O(p.pending(i));
+		} catch {
+			M(!0);
+		}
+	}, [
+		p,
+		i,
+		x,
+		k
+	]), a(() => (T.current = !0, () => {
+		T.current = !1;
+	}), []);
+	let N = _.data === void 0 ? void 0 : m(_.data), P = N?.filter((e) => e.expiresAt > y).reduce((e, t) => Math.min(e, t.expiresAt), Infinity);
+	if (a(() => {
+		if (P === void 0 || !Number.isFinite(P)) return;
+		let e = setTimeout(() => b(Date.now()), Math.min(2147483647, Math.max(1, P - Date.now())));
+		return () => clearTimeout(e);
+	}, [P, y]), _.error !== void 0) return /* @__PURE__ */ u("p", {
+		role: "alert",
+		children: g.unavailable
+	});
+	if (_.loading) return /* @__PURE__ */ u("p", {
+		role: "status",
+		children: g.loading
+	});
+	if (!N) return /* @__PURE__ */ u("p", {
+		role: "alert",
+		children: g.invalid
+	});
+	let F = N.filter((e) => e.expiresAt > y);
+	return /* @__PURE__ */ d("section", {
+		"data-quests": !0,
+		"aria-label": g.title,
+		children: [
+			D || j ? /* @__PURE__ */ u("button", {
+				type: "button",
+				"aria-disabled": x !== void 0 || k,
+				onClick: () => {
+					E.current || k || (E.current = !0, A(!0), M(!1), Promise.resolve().then(() => p.recover(i, (e) => v.run(e))).catch(() => {
+						T.current && M(!0);
+					}).finally(() => {
+						E.current = !1, T.current && A(!1);
+					}));
+				},
+				children: k ? g.recoverPending : g.recover
+			}) : null,
+			j ? /* @__PURE__ */ u("p", {
+				role: "alert",
+				children: g.rerollError
+			}) : null,
+			F.length === 0 ? /* @__PURE__ */ u("p", { children: g.empty }) : /* @__PURE__ */ u("ul", { children: F.map((e) => /* @__PURE__ */ u("li", { children: /* @__PURE__ */ u(f, {
+				quest: e,
+				now: y,
+				locale: o,
+				title: h?.(e),
+				blocked: x !== void 0 || k || D || j,
+				pending: x === e.id,
+				error: C === e.id,
+				onReroll: async () => {
+					if (!(E.current || e.expiresAt <= Date.now())) {
+						E.current = !0, S(e.id), w(void 0);
+						try {
+							await p.run(i, {
+								poolId: e.poolId,
+								windowId: e.windowId,
+								assignmentId: e.id
+							}, (e) => v.run(e));
+						} catch {
+							T.current && w(e.id);
+						} finally {
+							E.current = !1, T.current && S(void 0);
+						}
+					}
+				}
+			}) }, e.id)) })
+		]
+	});
+}
+function g(e) {
+	let t = l().quests;
+	return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/.test(e.invocationScope) ? /* @__PURE__ */ u(h, { ...e }, JSON.stringify([e.api ?? "app", e.invocationScope])) : /* @__PURE__ */ u("p", {
+		role: "alert",
+		children: t.invalid
+	});
+}
+export { f as QuestCard, g as QuestList };

package/dist/questPort.d.ts

@@ -0,0 +1,126 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare interface AssignQuestsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly poolId: string;
+    readonly requestId: string;
+    readonly expectedPoolDigest?: string;
+    readonly windowId: string;
+    readonly from: number;
+    readonly until: number;
+    readonly timezone: string;
+    readonly seed: number;
+}
+
+export declare interface PlayerQuest {
+    readonly id: string;
+    readonly poolId: string;
+    readonly windowId: string;
+    readonly quest: QuestDefinition;
+    readonly progress: readonly number[];
+    readonly state: 'active' | 'completed';
+    readonly assignedAt: number;
+    readonly expiresAt: number;
+    readonly rerollsUsed: number;
+    readonly rerollsAllowed: number;
+}
+
+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;
+
+declare interface QuestDefinition {
+    readonly id: string;
+    readonly titleKey?: string;
+    readonly objectives: readonly QuestObjective[];
+    readonly reward: readonly ProgressionReward[];
+}
+
+declare type QuestObjective = {
+    readonly stat: string;
+    readonly target: number;
+} | {
+    readonly event: string;
+    readonly target: number;
+    readonly where?: Readonly<Record<string, QuestScalar>>;
+};
+
+export declare class QuestPort extends QuestPort_base {
+}
+
+declare const QuestPort_base: Context.ServiceClass<QuestPort, "@voltro/QuestPort", QuestService>;
+
+export declare interface QuestReceipt {
+    readonly operationId: string;
+    readonly kind: 'assign' | 'record' | 'reroll';
+    readonly assignmentIds: readonly string[];
+    readonly completedIds: readonly string[];
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+declare type QuestScalar = string | number | boolean | null;
+
+export declare interface QuestService {
+    readonly assign: (subject: Subject, input: AssignQuestsInput) => Effect.Effect<QuestReceipt, ProgressionError>;
+    readonly record: (subject: Subject, input: RecordQuestInput) => Effect.Effect<QuestReceipt, ProgressionError>;
+    readonly reroll: (subject: Subject, input: RerollQuestInput) => Effect.Effect<QuestReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerQuest[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+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 interface RecordQuestInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly poolId: string;
+    readonly windowId: string;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+    readonly signal: QuestSignalInput;
+}
+
+export declare interface RerollQuestInput {
+    readonly poolId: string;
+    readonly windowId: string;
+    readonly assignmentId: string;
+    readonly requestId: string;
+}
+
+export { }

package/dist/questPort.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/questPort.ts
+var t = class extends e.Service()("@voltro/QuestPort") {};
+export { t as QuestPort };

package/dist/questRefresh.js

@@ -0,0 +1,55 @@
+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 { defineQuestPool as o, questTimezone as s } from "./quests.js";
+import { Context as c, Cron as l, Effect as u } from "effect";
+// src/questRefresh.ts
+var d = class extends c.Service()("@voltro/QuestPlayerSource") {}, f = ({ pool: t, player: n, at: r }) => {
+	let i = t.refresh.timezone === "player" ? n.timezone : t.refresh.timezone, a = l.parse(t.refresh.cron, i);
+	if (a._tag === "Failure") throw e("invalid_input");
+	let o = Math.floor(r / 1e3) * 1e3, s = l.match(a.success, new Date(o)) ? o : l.prev(a.success, new Date(o)).getTime();
+	return {
+		from: s,
+		until: l.next(a.success, new Date(s)).getTime(),
+		timezone: i
+	};
+}, p = (e) => {
+	let t = a(e, [
+		"tenantId",
+		"ownerId",
+		"timezone"
+	]);
+	return Object.freeze({
+		tenantId: n(t.tenantId),
+		ownerId: n(t.ownerId),
+		timezone: s(t.timezone)
+	});
+}, m = (t, n = f) => {
+	let i = o(t.pool), c = p(t.player), l = r(t.at, 0, 864e13), u = a(n(Object.freeze({
+		pool: i,
+		player: c,
+		at: l
+	})), [
+		"from",
+		"until",
+		"timezone"
+	]), d = r(u.from, 0, l), m = r(u.until, l + 1, 864e13), h = s(u.timezone);
+	if (m - d < 6e4 || m - d > 316224e5 || h !== (i.refresh.timezone === "player" ? c.timezone : i.refresh.timezone)) throw e("invalid_input");
+	return Object.freeze({
+		from: d,
+		until: m,
+		timezone: h
+	});
+}, h = class extends c.Service()("@voltro/QuestRefreshPort") {}, g = (t, n) => {
+	if (Array.isArray(t) && t.length > n) throw e("limit_exceeded");
+	let r = Object.freeze(i(t, n).map(p));
+	if (new Set(r.map((e) => JSON.stringify([e.tenantId, e.ownerId]))).size !== r.length) throw e("invalid_record");
+	return r;
+}, _ = (n, r) => {
+	try {
+		let e = t(n);
+		return u.suspend(() => r(e));
+	} catch {
+		return u.fail(e("invalid_input"));
+	}
+};
+export { d as QuestPlayerSource, h as QuestRefreshPort, p as captureQuestPlayer, g as captureQuestPlayers, _ as capturedRefresh, f as defaultQuestWindow, m as resolveQuestWindow };

package/dist/questRefresh.server.js

@@ -0,0 +1,125 @@
+import { ProgressionError as e, progressionError as t } from "./errors.js";
+import { identifier as n, integer as r, list as i, object as a } from "./capture.js";
+import { defineQuestPool as o } from "./quests.js";
+import { questHash as s } from "./questStore.js";
+import { captureQuestPlayer as c, captureQuestPlayers as l, capturedRefresh as u, defaultQuestWindow as d, resolveQuestWindow as f } from "./questRefresh.js";
+import { Effect as p, Result as m } from "effect";
+import { createHash as h } from "node:crypto";
+// src/questRefresh.server.ts
+var g = async (e) => {
+	let t = await p.runPromise(p.result(e));
+	if (m.isFailure(t)) throw t.failure;
+	return t.success;
+}, _ = (e) => h("sha256").update(JSON.stringify([
+	e.player.tenantId,
+	e.player.ownerId,
+	e.pool.id,
+	e.pool.version,
+	e.window.from,
+	e.window.until,
+	e.window.timezone
+])).digest().readUInt32BE(0) & 2147483647, v = (e) => {
+	let i = a(e, [
+		"players",
+		"intervalMs",
+		"maxPlayers",
+		"strategies",
+		"service"
+	]), o = a(i.players, ["read"]), s = a(i.strategies ?? {}, [
+		"questWindow",
+		"questSeed",
+		"version"
+	]), c = s.questWindow ?? d, l = s.questSeed ?? _;
+	if (typeof o.read != "function" || typeof c != "function" || typeof l != "function" || (c !== d || l !== _) && s.version === void 0) throw t("invalid_input");
+	let u = i.service === void 0 ? void 0 : a(i.service, ["refreshOwner", "refreshAll"]);
+	if (u && (typeof u.refreshOwner != "function" || typeof u.refreshAll != "function")) throw t("invalid_input");
+	return Object.freeze({
+		players: Object.freeze({ read: o.read }),
+		intervalMs: r(i.intervalMs ?? 6e4, 1e3, 36e5),
+		maxPlayers: r(i.maxPlayers ?? 1e3, 1, 1e4),
+		strategies: Object.freeze({
+			questWindow: c,
+			questSeed: l,
+			version: n(s.version ?? "default.v1")
+		}),
+		service: u
+	});
+}, y = (i, o, d) => {
+	let m = v(d), h = o.now ?? Date.now, _ = new Set(o.allowedServices ?? []), y = (e) => {
+		if (e.type !== "system" && !(e.type === "service" && _.has(e.service))) throw t("forbidden");
+	}, x = (n) => p.tryPromise({
+		try: n,
+		catch: (n) => n instanceof e ? n : t("unavailable")
+	}), S = async (e, t) => {
+		let i = a(await g(o.source.read({
+			tenantId: e.tenantId,
+			channel: o.channel,
+			locale: o.locale
+		})), ["revision", "pools"]);
+		n(i.revision);
+		let c = b(i.pools);
+		return Object.freeze(c.map((n) => {
+			let i = f({
+				pool: n,
+				player: e,
+				at: t
+			}, m.strategies.questWindow), a = r(m.strategies.questSeed(Object.freeze({
+				pool: n,
+				player: e,
+				at: t,
+				window: i
+			})), 0, 2147483647), o = s([
+				e.tenantId,
+				e.ownerId,
+				n.id,
+				n.version,
+				i.from,
+				i.until,
+				i.timezone,
+				m.strategies.version
+			]).slice(0, 56);
+			return Object.freeze({
+				tenantId: e.tenantId,
+				ownerId: e.ownerId,
+				poolId: n.id,
+				windowId: "refresh." + o,
+				requestId: "refresh." + o,
+				...i,
+				seed: a,
+				expectedPoolDigest: s(n)
+			});
+		}));
+	};
+	return Object.freeze({
+		refreshOwner: (e, t) => u({
+			subject: e,
+			player: t
+		}, (e) => x(async () => {
+			y(e.subject);
+			let t = c(e.player), n = r(h(), 0, 864e13), a = await S(t, n), o = [];
+			for (let t of a) o.push(await g(i.assign(e.subject, t)));
+			return Object.freeze(o);
+		})),
+		refreshAll: (t) => u(t, (t) => x(async () => {
+			y(t);
+			let n = r(h(), 0, 864e13), a = l(await g(m.players.read({ limit: m.maxPlayers })), m.maxPlayers), o = 0, s = 0, c = [];
+			for (let r of a) try {
+				let e = await S(r, n);
+				for (let n of e) await g(i.assign(t, n)), o++;
+			} catch (t) {
+				t instanceof e && t.code === "erased" ? s++ : c.push(t instanceof e ? t.code : "unavailable");
+			}
+			return Object.freeze({
+				players: a.length,
+				assignments: o,
+				erased: s,
+				failures: Object.freeze(c)
+			});
+		}))
+	});
+}, b = (e) => {
+	let n = Object.freeze(i(e, 64).map((e) => o(e)));
+	if (new Set(n.map((e) => e.id)).size !== n.length) throw t("invalid_record");
+	return n;
+};
+export { _ as defaultQuestSeed, y as makeQuestRefreshService, v as resolveQuestRefreshOptions };

package/dist/questRerollJournal.js

@@ -0,0 +1,76 @@
+import { QuestReceiptSchema as e, questsRerollDescriptor as t } from "./rpc.js";
+import { Schema as n } from "effect";
+// src/questRerollJournal.ts
+var r = (e) => {
+	if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/.test(e)) throw Error("Invalid quest request scope");
+	return e;
+}, i = n.decodeUnknownSync(t.input, { onExcessProperty: "error" }), a = (t, i) => {
+	let a = n.decodeUnknownSync(e, { onExcessProperty: "error" })(t);
+	if (a.kind !== "reroll" || !Number.isSafeInteger(a.at) || a.at < 0 || a.at > 864e13 || a.assignmentIds.length !== 1 || a.assignmentIds[0] === i.assignmentId || a.completedIds.length !== 0 || a.rewardsQueued !== 0) throw Error("Unconfirmed quest reroll receipt");
+	return r(a.operationId), r(a.assignmentIds[0]), a;
+}, o = (e) => {
+	let t = (e) => "voltro.quest-reroll." + r(e), n = (t) => {
+		let n = e.storage.getItem(t);
+		if (n === null) return;
+		if (n.length > 4096) throw Error("Invalid quest reroll journal");
+		let o = JSON.parse(n);
+		if (!o || typeof o != "object" || Array.isArray(o) || Object.keys(o).length !== 2 || !Object.hasOwn(o, "intent") || !Object.hasOwn(o, "receipt")) throw Error("Invalid quest reroll journal");
+		let s = o, c = i(s.intent);
+		return Object.values(c).forEach(r), {
+			intent: c,
+			receipt: s.receipt === null ? null : a(s.receipt, c)
+		};
+	}, o = (t, n) => {
+		let r = JSON.stringify(n);
+		if (e.storage.setItem(t, r), e.storage.getItem(t) !== r) throw Error("Quest request identity was not acknowledged");
+	}, s = async (e, t, n) => {
+		o(e, {
+			intent: t,
+			receipt: null
+		});
+		let r = a(await n(Object.freeze(t)), t);
+		return o(e, {
+			intent: t,
+			receipt: r
+		}), r;
+	};
+	return {
+		pending: (e) => n(t(e))?.receipt === null,
+		recover: (r, i) => {
+			let a = t(r);
+			return e.exclusive(a, async () => {
+				let e = n(a);
+				return e ? e.receipt ?? s(a, e.intent, i) : void 0;
+			});
+		},
+		run: async (a, o, c) => {
+			let l = Object.freeze({
+				poolId: r(o.poolId),
+				windowId: r(o.windowId),
+				assignmentId: r(o.assignmentId)
+			}), u = t(a);
+			return e.exclusive(u, async () => {
+				let t = n(u), a = t && t.intent.poolId === l.poolId && t.intent.windowId === l.windowId && t.intent.assignmentId === l.assignmentId;
+				if (t && a && t.receipt) return t.receipt;
+				if (t && !a && t.receipt === null) throw Error("Another quest reroll is unconfirmed");
+				let o = t && a ? t.intent : i({
+					...l,
+					requestId: r(e.requestId())
+				});
+				return s(u, o, c);
+			});
+		}
+	};
+}, s = () => {
+	if (typeof navigator > "u" || !navigator.locks || typeof localStorage > "u" || typeof crypto > "u" || typeof crypto.randomUUID != "function") throw Error("Durable quest reroll storage and Web Locks are required");
+	return o({
+		storage: localStorage,
+		exclusive: (e, t) => navigator.locks.request(e, { mode: "exclusive" }, t),
+		requestId: () => crypto.randomUUID()
+	});
+}, c = {
+	run: (e, t, n) => s().run(e, t, n),
+	pending: (e) => s().pending(e),
+	recover: (e, t) => s().recover(e, t)
+};
+export { c as browserQuestRerollJournal, o as makeQuestRerollJournal };