@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/server.js

@@ -0,0 +1,21 @@
+import { progressionDefinitionsTable as e, progressionOperationsTable as t, progressionOriginsTable as n, progressionRewardsTable as r, progressionStatLedgerTable as i, progressionStatsTable as a, progressionSubjectsTable as o, progressionTables as s, progressionTracksTable as c, progressionXpLedgerTable as l } from "./tables.entity.js";
+import { dataStoreProgression as u, resolveProgressionOptions as d } from "./progressionStore.js";
+import { questDefinitionsTable as f, questOperationsTable as p, questOriginsTable as m, questRewardsTable as h, questSubjectsTable as g, questTables as _, questWindowsTable as v, questsTable as y } from "./questTables.entity.js";
+import { dataStoreQuests as b, resolveQuestOptions as x } from "./questStore.js";
+import { defaultQuestSeed as S, makeQuestRefreshService as C, resolveQuestRefreshOptions as w } from "./questRefresh.server.js";
+import { resourceDefinitionsTable as T, resourceMovementsTable as E, resourceOperationsTable as D, resourceOriginsTable as O, resourceSubjectsTable as k, resourceTables as A, resourcesTable as j } from "./resourceTables.entity.js";
+import { dataStoreResources as M, resolveResourceOptions as N } from "./resourceStore.js";
+import { achievementDefinitionsTable as P, achievementOperationsTable as F, achievementRewardsTable as I, achievementSubjectsTable as L, achievementTables as R, achievementUnlockLedgerTable as z, achievementsTable as B } from "./achievementTables.entity.js";
+import { captureAchievementHistory as V, dataStoreAchievements as H, resolveAchievementOptions as U } from "./achievementStore.js";
+import { dailyClaimsTable as W, dailyDefinitionsTable as G, dailyOperationsTable as K, dailyRewardsTable as q, dailyStatesTable as J, dailySubjectsTable as Y, dailyTables as X } from "./dailyTables.entity.js";
+import { passDefinitionsTable as Z, passLedgerTable as Q, passOperationsTable as $, passRewardsTable as ee, passStatesTable as te, passSubjectsTable as ne, passTables as re } from "./passTables.entity.js";
+import { tutorialDefinitionsTable as ie, tutorialLedgerTable as ae, tutorialOperationsTable as oe, tutorialRewardsTable as se, tutorialStatesTable as ce, tutorialSubjectsTable as le, tutorialTables as ue } from "./tutorialTables.entity.js";
+import { rankClosureUnitsTable as de, rankDefinitionsTable as fe, rankLedgerTable as pe, rankOperationsTable as me, rankRewardsTable as he, rankStatesTable as ge, rankSubjectsTable as _e, rankTables as ve } from "./rankTables.entity.js";
+import { dataStoreRewardDelivery as ye, resolveRewardDeliveryOptions as be } from "./rewardDelivery.server.js";
+import { dataStoreLoginCalendars as xe, resolveDailyOptions as Se } from "./dailyStore.js";
+import { dataStoreSeasonPasses as Ce, resolvePassOptions as we } from "./passStore.js";
+import { dataStoreTutorials as Te, resolveTutorialOptions as Ee } from "./tutorialStore.js";
+import { dataStoreRankSeasons as De, resolveRankStoreOptions as Oe } from "./rankStore.js";
+import { dataStoreRankClosure as ke, resolveRankClosureOptions as Ae } from "./rankClosure.server.js";
+import { makeRankReader as je, ratingSourceFromLeaderboards as Me } from "./rankReader.server.js";
+export { P as achievementDefinitionsTable, F as achievementOperationsTable, I as achievementRewardsTable, L as achievementSubjectsTable, R as achievementTables, z as achievementUnlockLedgerTable, B as achievementsTable, V as captureAchievementHistory, W as dailyClaimsTable, G as dailyDefinitionsTable, K as dailyOperationsTable, q as dailyRewardsTable, J as dailyStatesTable, Y as dailySubjectsTable, X as dailyTables, H as dataStoreAchievements, xe as dataStoreLoginCalendars, u as dataStoreProgression, b as dataStoreQuests, ke as dataStoreRankClosure, De as dataStoreRankSeasons, M as dataStoreResources, ye as dataStoreRewardDelivery, Ce as dataStoreSeasonPasses, Te as dataStoreTutorials, S as defaultQuestSeed, C as makeQuestRefreshService, je as makeRankReader, Z as passDefinitionsTable, Q as passLedgerTable, $ as passOperationsTable, ee as passRewardsTable, te as passStatesTable, ne as passSubjectsTable, re as passTables, e as progressionDefinitionsTable, t as progressionOperationsTable, n as progressionOriginsTable, r as progressionRewardsTable, i as progressionStatLedgerTable, a as progressionStatsTable, o as progressionSubjectsTable, s as progressionTables, c as progressionTracksTable, l as progressionXpLedgerTable, f as questDefinitionsTable, p as questOperationsTable, m as questOriginsTable, h as questRewardsTable, g as questSubjectsTable, _ as questTables, v as questWindowsTable, y as questsTable, de as rankClosureUnitsTable, fe as rankDefinitionsTable, pe as rankLedgerTable, me as rankOperationsTable, he as rankRewardsTable, ge as rankStatesTable, _e as rankSubjectsTable, ve as rankTables, Me as ratingSourceFromLeaderboards, U as resolveAchievementOptions, Se as resolveDailyOptions, we as resolvePassOptions, d as resolveProgressionOptions, x as resolveQuestOptions, w as resolveQuestRefreshOptions, Ae as resolveRankClosureOptions, Oe as resolveRankStoreOptions, N as resolveResourceOptions, be as resolveRewardDeliveryOptions, Ee as resolveTutorialOptions, T as resourceDefinitionsTable, E as resourceMovementsTable, D as resourceOperationsTable, O as resourceOriginsTable, k as resourceSubjectsTable, A as resourceTables, j as resourcesTable, ie as tutorialDefinitionsTable, ae as tutorialLedgerTable, oe as tutorialOperationsTable, se as tutorialRewardsTable, ce as tutorialStatesTable, le as tutorialSubjectsTable, ue as tutorialTables };

package/dist/stats.js

@@ -0,0 +1,44 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, list as n, object as r, progressValue as i } from "./capture.js";
+// src/stats.ts
+var a = [
+	"increment",
+	"max",
+	"min",
+	"set"
+], o = (o) => {
+	let s = r(o, [
+		"id",
+		"initial",
+		"cap",
+		"operators"
+	]), c = i(s.initial ?? "0"), l = i(s.cap ?? "9223372036854775807"), u = n(s.operators ?? a, 4);
+	if (c > l || u.length === 0 || new Set(u).size !== u.length || u.some((e) => !a.some((t) => t === e))) throw e("invalid_stat");
+	return Object.freeze({
+		id: t(s.id),
+		initial: String(c),
+		cap: String(l),
+		operators: Object.freeze(u)
+	});
+}, s = (t, n, r, a) => {
+	let s = o(a);
+	if (!s.operators.includes(r)) throw e("forbidden");
+	let c = i(t ?? s.initial), l = i(n);
+	if (c > BigInt(s.cap)) throw e("invalid_record");
+	let u;
+	switch (r) {
+		case "increment":
+			u = c + l;
+			break;
+		case "max":
+			u = l > c ? l : c;
+			break;
+		case "min":
+			u = t === null || l < c ? l : c;
+			break;
+		case "set": u = l;
+	}
+	if (u > BigInt(s.cap)) throw e("overflow");
+	return String(i(u));
+};
+export { a as STAT_OPERATORS, s as applyStatValue, o as defineStat };

package/dist/strategies.d.ts

@@ -0,0 +1,131 @@
+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 defaultRewardResolver: RewardResolver;
+
+export declare const defaultXpCurve: XpCurve;
+
+declare interface LevelCurve {
+    readonly thresholds: readonly string[];
+}
+
+declare interface LevelReward {
+    readonly level: number;
+    readonly reward: ProgressionReward;
+}
+
+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 interface ProgressionTrack {
+    readonly id: string;
+    readonly version: number;
+    readonly xpCurve: LevelCurve;
+    readonly sources: readonly string[];
+    readonly rewards: Readonly<Record<string, readonly ProgressionReward[]>>;
+    readonly every: Readonly<Record<string, readonly ProgressionReward[]>>;
+}
+
+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>>;
+};
+
+declare interface QuestPool extends QuestPoolDefinition {
+    readonly version: number;
+    readonly rerolls: number;
+    readonly weights: Readonly<Record<string, number>>;
+}
+
+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[];
+
+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[];
+}
+
+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 const resolveQuestProgress: (input: QuestProgressContext, slot?: QuestProgressResolver) => readonly number[];
+
+export declare const resolveRewards: (context: RewardResolverContext, slot?: RewardResolver) => readonly LevelReward[];
+
+export declare const resolveXpCurve: (xp: ProgressValue, curve: LevelCurve, slot?: XpCurve) => number;
+
+export declare type RewardResolver = (context: RewardResolverContext) => readonly LevelReward[];
+
+export declare interface RewardResolverContext {
+    readonly track: ProgressionTrack;
+    readonly fromLevel: number;
+    readonly toLevel: number;
+}
+
+export declare const selectQuests: (input: QuestSelectorContext, slot?: QuestSelector) => readonly string[];
+
+export declare type XpCurve = (context: XpCurveContext) => number;
+
+export declare interface XpCurveContext {
+    readonly xp: string;
+    readonly curve: LevelCurve;
+}
+
+export { }

package/dist/strategies.js

@@ -0,0 +1,4 @@
+import { defaultQuestProgressResolver as e, defaultQuestSelector as t, resolveQuestProgress as n, selectQuests as r } from "./quests.js";
+import { defaultXpCurve as i, resolveXpCurve as a } from "./curve.js";
+import { defaultRewardResolver as o, resolveRewards as s } from "./track.js";
+export { e as defaultQuestProgressResolver, t as defaultQuestSelector, o as defaultRewardResolver, i as defaultXpCurve, n as resolveQuestProgress, s as resolveRewards, a as resolveXpCurve, r as selectQuests };

package/dist/systemFixtures.js

@@ -0,0 +1,473 @@
+import { SeasonPassPort as e, defaultPassCatchUp as t, defineSeasonPass as n, resolvePassCatchUp as r } from "./pass.js";
+import { QuestSource as i, defaultQuestProgressResolver as a, defaultQuestSelector as o, defineQuestPool as s, resolveQuestProgress as c, selectQuests as l, staticQuestSource as ee } from "./quests.js";
+import { defaultXpCurve as u, resolveXpCurve as d } from "./curve.js";
+import { ProgressionPort as f } from "./port.js";
+import { defaultRewardResolver as te, resolveRewards as p, trackDeclaration as m } from "./track.js";
+import { QuestPort as h } from "./questPort.js";
+import { RegenResourcePort as g, defaultResourceRegen as _, resolveResourceRegen as v } from "./resources.js";
+import { AchievementPort as y, AchievementStatSource as b, defaultAchievementEvaluator as x, resolveAchievementEvaluation as S, statAtLeast as C } from "./achievements.js";
+import { progressionPlugin as ne } from "./plugin.js";
+import { passFixture as re, progressionFixture as ie, resourceFixture as w } from "./declarationFixtures.js";
+import { Effect as T, Layer as E } from "effect";
+import { systemSubject as D } from "@voltro/protocol";
+import { ensureTableRegistered as O } from "@voltro/database";
+import { InMemoryDataStore as k } from "@voltro/runtime";
+// src/systemFixtures.ts
+var A = Date.UTC(2026, 9, 10), j = ie(), M = w(), N = s({
+	id: "fixture.daily",
+	version: 1,
+	slots: 1,
+	rerolls: 1,
+	refresh: {
+		cron: "0 4 * * *",
+		timezone: "UTC"
+	},
+	quests: [{
+		id: "fixture.first",
+		objectives: [{
+			event: "match.finished",
+			target: 2
+		}],
+		reward: []
+	}, {
+		id: "fixture.second",
+		objectives: [{
+			event: "match.finished",
+			target: 2
+		}],
+		reward: []
+	}]
+}), ae = ee([N], "fixture.r1"), P = re(), F = n({
+	...P.pass,
+	from: A,
+	until: A + 2592e6,
+	sources: ["match.finished"]
+}), I = {
+	app: {
+		name: "progression-port-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, L = E.effectContext(T.acquireRelease(T.sync(() => ne({
+	tracks: [m(j.track)],
+	stats: [{ id: "wins" }],
+	statSources: ["match.finished"],
+	now: () => A,
+	quests: {
+		source: ae,
+		channel: "live",
+		locale: "en",
+		eventSources: ["match.finished"],
+		now: () => A
+	},
+	resources: {
+		definitions: [M.resource],
+		sources: ["match.started", "players.created"],
+		now: () => A
+	},
+	achievements: {
+		definitions: [{
+			id: "fixture.wins",
+			hidden: !0,
+			condition: C("wins", "2"),
+			reward: []
+		}],
+		now: () => A
+	},
+	passes: {
+		definitions: [F],
+		now: () => A
+	}
+})), (e) => T.suspend(() => e.onDeactivate(I))).pipe(T.tap((e) => T.gen(function* () {
+	e.extendSchema.tables.forEach((e) => O(e)), yield* T.promise(() => Promise.resolve(e.bindDataStore(new k())));
+}).pipe(T.orDie)), T.flatMap((e) => E.build(e.services)))), R = L, z = L, B = L, V = L, H = L, U = L, W = L, G = D("progression.system.fixture"), K = {
+	type: "user",
+	id: "a",
+	tenantId: "fixture",
+	kind: "guest"
+}, q = {
+	tenantId: "fixture",
+	ownerId: "a"
+}, oe = Object.freeze({
+	kind: "port",
+	tag: f,
+	fakeLayer: R,
+	probe: {
+		run: () => T.scoped(T.gen(function* () {
+			let e = yield* f, t = {
+				...q,
+				trackId: j.track.id,
+				amount: "100",
+				requestId: "fixture.xp",
+				source: "match.finished",
+				origin: "fixture.match"
+			}, n = yield* e.applyXp(G, t), r = yield* e.applyXp(G, t);
+			return yield* e.applyStat(G, {
+				...q,
+				stat: "wins",
+				period: "lifetime",
+				operator: "increment",
+				operand: "1",
+				requestId: "fixture.stat",
+				source: "match.finished",
+				origin: "fixture.match"
+			}), {
+				original: n.operationId === r.operationId,
+				tracks: (yield* e.mine(K)).map((e) => ({
+					xp: e.xp,
+					level: e.level
+				})),
+				stats: (yield* e.stats(K)).map((e) => e.value),
+				rewardsQueued: n.rewardsQueued
+			};
+		}).pipe(T.provide(R))),
+		expected: {
+			original: !0,
+			tracks: [{
+				xp: "100",
+				level: 2
+			}],
+			stats: ["1"],
+			rewardsQueued: 1
+		}
+	}
+}), se = Object.freeze({
+	kind: "port",
+	tag: h,
+	fakeLayer: z,
+	probe: {
+		run: () => T.scoped(T.gen(function* () {
+			let e = yield* h;
+			yield* e.assign(G, {
+				...q,
+				poolId: N.id,
+				requestId: "fixture.assign",
+				windowId: "fixture.day",
+				from: A,
+				until: A + 864e5,
+				timezone: "UTC",
+				seed: 1
+			});
+			let t = {
+				...q,
+				poolId: N.id,
+				windowId: "fixture.day",
+				requestId: "fixture.record",
+				source: "match.finished",
+				origin: "fixture.match",
+				signal: {
+					kind: "event",
+					event: "match.finished",
+					data: {}
+				}
+			}, n = yield* e.record(G, t), r = yield* e.record(G, t);
+			return {
+				original: n.operationId === r.operationId,
+				quests: (yield* e.mine(K)).map((e) => ({
+					progress: e.progress,
+					state: e.state
+				}))
+			};
+		}).pipe(T.provide(z))),
+		expected: {
+			original: !0,
+			quests: [{
+				progress: [1],
+				state: "active"
+			}]
+		}
+	}
+}), ce = Object.freeze({
+	kind: "port",
+	tag: i,
+	fakeLayer: B,
+	probe: {
+		run: () => T.scoped(T.gen(function* () {
+			let e = yield* (yield* i).read({
+				tenantId: "fixture",
+				channel: "live",
+				locale: "en"
+			});
+			return {
+				revision: e.revision,
+				pools: e.pools.map((e) => e.id)
+			};
+		}).pipe(T.provide(B))),
+		expected: {
+			revision: "fixture.r1",
+			pools: ["fixture.daily"]
+		}
+	}
+}), le = Object.freeze({
+	kind: "port",
+	tag: g,
+	fakeLayer: V,
+	probe: {
+		run: () => T.scoped(T.gen(function* () {
+			let e = yield* g;
+			yield* e.initialize(G, {
+				...q,
+				resourceId: M.resource.id,
+				requestId: "fixture.initialize",
+				source: "players.created",
+				origin: "fixture.player"
+			});
+			let t = {
+				...q,
+				resourceId: M.resource.id,
+				amount: "3",
+				requestId: "fixture.consume",
+				source: "match.started",
+				origin: "fixture.match"
+			}, n = yield* e.consume(G, t), r = yield* e.consume(G, t);
+			return {
+				original: n.operationId === r.operationId,
+				values: (yield* e.mine(K)).map((e) => e.value)
+			};
+		}).pipe(T.provide(V))),
+		expected: {
+			original: !0,
+			values: ["7"]
+		}
+	}
+}), J = {
+	...q,
+	stat: "wins",
+	period: "lifetime",
+	operator: "increment",
+	operand: "2",
+	requestId: "fixture.achievement.stat",
+	source: "match.finished",
+	origin: "fixture.achievement.match"
+}, ue = Object.freeze({
+	kind: "port",
+	tag: y,
+	fakeLayer: H,
+	probe: {
+		run: () => T.scoped(T.gen(function* () {
+			let e = yield* f, t = yield* y;
+			yield* e.applyStat(G, J);
+			let n = {
+				...q,
+				requestId: "fixture.evaluate"
+			}, r = yield* t.evaluate(G, n), i = yield* t.evaluate(G, n);
+			return {
+				original: r.operationId === i.operationId,
+				achievements: (yield* t.mine(K)).map((e) => ({
+					id: e.achievementId,
+					tier: e.tierId,
+					unlocked: e.unlocked,
+					value: e.progress[0]?.value
+				}))
+			};
+		}).pipe(T.provide(H))),
+		expected: {
+			original: !0,
+			achievements: [{
+				id: "fixture.wins",
+				tier: "base",
+				unlocked: !0,
+				value: "2"
+			}]
+		}
+	}
+}), de = Object.freeze({
+	kind: "port",
+	tag: b,
+	fakeLayer: U,
+	probe: {
+		run: () => T.scoped(T.gen(function* () {
+			let e = yield* f, t = yield* b;
+			return yield* e.applyStat(G, J), (yield* t.history(G, {
+				...q,
+				limit: 100
+			})).events.map((e) => ({
+				stat: e.stat,
+				value: e.value
+			}));
+		}).pipe(T.provide(U))),
+		expected: [{
+			stat: "wins",
+			value: "2"
+		}]
+	}
+}), fe = Object.freeze({
+	kind: "port",
+	tag: e,
+	fakeLayer: W,
+	probe: {
+		run: () => T.scoped(T.gen(function* () {
+			let t = yield* e;
+			yield* t.applyXp(G, {
+				...q,
+				passId: F.id,
+				amount: "100",
+				requestId: "fixture.pass.xp",
+				source: "match.finished",
+				originId: "fixture.match"
+			});
+			let n = {
+				passId: F.id,
+				tier: 1,
+				track: "free",
+				requestId: "fixture.pass.claim"
+			}, r = yield* t.claim(K, n), i = yield* t.claim(K, n);
+			return {
+				original: r.operationId === i.operationId,
+				claimedFree: r.after.claimedFree,
+				rewardsQueued: r.rewardsQueued,
+				passes: (yield* t.mine(K)).map((e) => ({
+					xp: e.xp,
+					tier: e.tier,
+					claimedFree: e.claimedFree
+				}))
+			};
+		}).pipe(T.provide(W))),
+		expected: {
+			original: !0,
+			claimedFree: "1",
+			rewardsQueued: 1,
+			passes: [{
+				xp: "100",
+				tier: 1,
+				claimedFree: "1"
+			}]
+		}
+	}
+}), pe = Object.freeze({
+	kind: "slot",
+	defaultImplementation: u,
+	defaultProbe: {
+		run: () => T.sync(() => d(j.xpCurve.xp, j.curve)),
+		expected: 2
+	},
+	overrideProbe: {
+		run: () => T.sync(() => d(j.xpCurve.xp, j.curve, () => 3)),
+		expected: 3
+	}
+}), me = Object.freeze({
+	kind: "slot",
+	defaultImplementation: te,
+	defaultProbe: {
+		run: () => T.sync(() => p(j.rewardResolver)),
+		expected: [{
+			level: 2,
+			reward: {
+				kind: "currency",
+				currency: "test.gold",
+				amount: "5"
+			}
+		}]
+	},
+	overrideProbe: {
+		run: () => T.sync(() => p(j.rewardResolver, () => [])),
+		expected: []
+	}
+}), Y = {
+	pool: N,
+	count: 1,
+	seed: 1,
+	excluded: []
+}, he = Object.freeze({
+	kind: "slot",
+	defaultImplementation: o,
+	defaultProbe: {
+		run: () => T.sync(() => l(Y)),
+		expected: ["fixture.first"]
+	},
+	overrideProbe: {
+		run: () => T.sync(() => l(Y, () => ["fixture.second"])),
+		expected: ["fixture.second"]
+	}
+}), X = {
+	quest: N.quests[0],
+	progress: [0],
+	signal: {
+		kind: "event",
+		event: "match.finished",
+		data: {}
+	}
+}, ge = Object.freeze({
+	kind: "slot",
+	defaultImplementation: a,
+	defaultProbe: {
+		run: () => T.sync(() => c(X)),
+		expected: [1]
+	},
+	overrideProbe: {
+		run: () => T.sync(() => c(X, () => [2])),
+		expected: [2]
+	}
+}), _e = Object.freeze({
+	kind: "slot",
+	defaultImplementation: _,
+	defaultProbe: {
+		run: () => T.sync(() => v(M)),
+		expected: {
+			value: "7",
+			anchorAt: 3e3
+		}
+	},
+	overrideProbe: {
+		run: () => T.sync(() => v(M, () => ({
+			value: "6",
+			anchorAt: 2e3
+		}))),
+		expected: {
+			value: "6",
+			anchorAt: 2e3
+		}
+	}
+}), Z = C("wins", "2"), Q = [{
+	stat: "wins",
+	period: "lifetime",
+	seasonId: null,
+	value: "2"
+}], $ = [{
+	stat: "wins",
+	period: "lifetime",
+	seasonId: null,
+	value: "2",
+	target: "2",
+	met: !0
+}], ve = Object.freeze({
+	kind: "slot",
+	defaultImplementation: x,
+	defaultProbe: {
+		run: () => T.sync(() => S(Z, Q)),
+		expected: {
+			met: !0,
+			progress: $
+		}
+	},
+	overrideProbe: {
+		run: () => T.sync(() => S(Z, Q, (e) => ({
+			...x(e),
+			met: !1
+		}))),
+		expected: {
+			met: !1,
+			progress: $
+		}
+	}
+}), ye = Object.freeze({
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => T.sync(() => r(P.passCatchUp)),
+		expected: "200"
+	},
+	overrideProbe: {
+		run: () => T.sync(() => r(P.passCatchUp, (e) => e.amount)),
+		expected: "100"
+	}
+});
+export { ve as achievementEvaluatorSystemFixture, H as achievementFakeLayer, ue as achievementPortSystemFixture, U as achievementStatSourceFakeLayer, de as achievementStatSourceSystemFixture, ye as passCatchUpSystemFixture, W as passFakeLayer, fe as passPortSystemFixture, R as progressionFakeLayer, oe as progressionPortSystemFixture, z as questFakeLayer, se as questPortSystemFixture, ge as questProgressResolverSystemFixture, he as questSelectorSystemFixture, B as questSourceFakeLayer, ce as questSourceSystemFixture, V as resourceFakeLayer, le as resourcePortSystemFixture, _e as resourceRegenSystemFixture, me as rewardResolverSystemFixture, pe as xpCurveSystemFixture };