@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/dailyStore.js

@@ -0,0 +1,420 @@
+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 { captureDailyProfile as s, captureDailyState as c, defaultDailyClaimPolicy as l, defaultDailyWindow as u, defineLoginCalendar as d, resolveDailyClaim as f } from "./daily.js";
+import { admitRewardDeliveryRecord as p } from "./rewardDeliveryRecord.js";
+import { questHash as m } from "./questStore.js";
+import { dailyClaimsTable as h, dailyDefinitionsTable as g, dailyOperationsTable as _, dailyRewardsTable as v, dailyStatesTable as y, dailySubjectsTable as b } from "./dailyTables.entity.js";
+import { Effect as x, Result as S } from "effect";
+import { and as C, eq as w, queryFor as T } from "@voltro/database";
+// src/dailyStore.ts
+var E = (e) => {
+	let n = o(e, [
+		"calendars",
+		"profileSource",
+		"now",
+		"maxHistoryRows",
+		"allowedServices",
+		"strategies"
+	]), s = o(n.profileSource), c = o(n.strategies ?? {}, ["claimPolicy", "version"]), u = Object.freeze(a(n.calendars, 64).map((e) => d(e))), f = n.now ?? Date.now, p = c.claimPolicy ?? l, m = Object.freeze(a(n.allowedServices ?? [], 256).map(r));
+	if (!u.length || new Set(u.map((e) => e.id)).size !== u.length || new Set(m).size !== m.length || typeof s.read != "function" || typeof f != "function" || typeof p != "function" || p !== l && c.version === void 0) throw t("invalid_input");
+	return Object.freeze({
+		calendars: u,
+		profileSource: Object.freeze({ read: s.read }),
+		now: f,
+		maxHistoryRows: i(n.maxHistoryRows ?? 1e4, 1, 1e5),
+		allowedServices: m,
+		strategies: Object.freeze({
+			claimPolicy: p,
+			version: r(c.version ?? "default.v1")
+		})
+	});
+}, D = (e, ...t) => e + m(t).slice(0, 56), O = (e) => i(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN, 0, 864e13), k = (n) => x.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), A = (a, d) => {
+	let A = E(d), j = new Map(A.calendars.map((e) => [e.id, e])), M = new Set(A.allowedServices), N = () => i(A.now(), 0, 864e13), P = (e) => {
+		let n = j.get(e);
+		if (!n) throw t("invalid_input");
+		return n;
+	}, F = (e) => {
+		if (e.type !== "user" || !e.tenantId) throw t("forbidden");
+		return {
+			tenantId: r(e.tenantId),
+			ownerId: r(e.id)
+		};
+	}, I = (e) => {
+		if (e.type !== "system" && !(e.type === "service" && M.has(e.service))) throw t("forbidden");
+	}, L = (e, t) => D("pds_", e, t), R = (e, t) => C(w("tenantId", e), w("ownerKey", L(e, t))), z = async (e, n) => {
+		if ((await a.insertIgnoreWithOutcome(e.tableName, n, { conflictColumns: ["id"] })).outcome !== "inserted" && !(await a.query(T(e).where(w("id", n.id)).limit(1).descriptor))[0]) throw t("unavailable");
+	}, B = (e, t) => z(b, {
+		id: L(e, t),
+		tenantId: e,
+		ownerId: t,
+		erased: !1,
+		sequence: 0,
+		admission: 0
+	}), V = (e, n, r) => {
+		if (e) {
+			if (e.id !== L(n, r) || e.tenantId !== n || typeof e.erased != "boolean") throw t("invalid_record");
+			if (e.erased) throw e.ownerId === null ? t("erased") : t("invalid_record");
+			if (e.ownerId !== r) throw t("invalid_record");
+			i(e.sequence, 0, 2147483647);
+		}
+	}, H = async (e, n, r) => {
+		if (await e.updateMany(b.tableName, { admission: 0 }, { where: w("id", L(n, r)) }) !== 1) throw t("invalid_record");
+		let i = (await e.query(T(b).where(w("id", L(n, r))).limit(1).descriptor))[0];
+		if (V(i, n, r), !i) throw t("invalid_record");
+		return i;
+	}, U = async (e, n, r, i) => {
+		let a = await e.query(T(n).where(R(r, i)).limit(A.maxHistoryRows + 1).descriptor);
+		if (a.length > A.maxHistoryRows) throw t("limit_exceeded");
+		if (a.some((e) => e.tenantId !== r || e.ownerKey !== L(r, i))) throw t("invalid_record");
+		return a;
+	}, W = (e, n, a) => {
+		let s = o(e.receipt, [
+			"operationId",
+			"claimId",
+			"calendarId",
+			"dayKey",
+			"after",
+			"rewardsQueued",
+			"at"
+		]), l = P(r(s.calendarId)), u = c(s.after, l);
+		if (e.state !== "committed" || s.operationId !== e.id || s.claimId !== D("pdl_", n, a, l.id, String(l.version), String(u.dayOrdinal)) || s.dayKey !== u.dayKey || s.at !== u.at || s.at !== O(e.at) || s.rewardsQueued !== l.days[u.dayIndex].length) throw t("invalid_record");
+		return Object.freeze({
+			operationId: r(e.id),
+			claimId: r(s.claimId),
+			calendarId: l.id,
+			dayKey: u.dayKey,
+			after: u,
+			rewardsQueued: i(s.rewardsQueued, 0, 64),
+			at: u.at
+		});
+	}, G = async (e, n, r, i, a) => {
+		let o = (await e.query(T(_).where(w("id", n)).limit(1).descriptor))[0];
+		if (!o) return;
+		if (o.state === "erased") throw t("erased");
+		if (o.tenantId !== i || o.ownerKey !== L(i, a) || o.digest !== r) throw t("conflict");
+		if (o.state === "committed" && o.linkedOperationId === null) return W(o, i, a);
+		if (o.state !== "replayed" || typeof o.linkedOperationId != "string" || o.receipt !== null) throw t("invalid_record");
+		let s = (await e.query(T(_).where(w("id", o.linkedOperationId)).limit(1).descriptor))[0];
+		if (!s || s.tenantId !== i || s.ownerKey !== L(i, a) || s.digest !== r || s.linkedOperationId !== null) throw t("invalid_record");
+		return W(s, i, a);
+	}, K = async (e, t, n) => {
+		let r = await x.runPromise(x.result(A.profileSource.read(e, {
+			tenantId: t,
+			ownerId: n
+		})));
+		if (S.isFailure(r)) throw r.failure;
+		return s(r.success);
+	}, q = (e, n, r, i) => {
+		if (e.id !== D("pdv_", n, r, i.id, String(i.version)) || e.tenantId !== n || e.ownerId !== r || e.calendarId !== i.id || e.version !== i.version) throw t("invalid_record");
+		let a = c(e.state, i);
+		if (O(e.updatedAt) !== a.at) throw t("invalid_record");
+		return a;
+	}, J = (s, c) => {
+		try {
+			let e = n(s), { tenantId: l, ownerId: d } = F(e), p = o(c, ["calendarId", "requestId"]), x = P(r(p.calendarId)), S = D("pdo_", l, d, r(p.requestId)), C = m({
+				tenantId: l,
+				ownerId: d,
+				calendarId: x.id,
+				version: x.version
+			});
+			return k(async () => {
+				await B(l, d);
+				let n = await a.transactional(async (e) => (await H(e, l, d), G(e, S, C, l, d)));
+				if (n) return n;
+				let r = await K(e, l, d), o = N(), s = u({
+					timezone: r.timezone,
+					at: o
+				});
+				return await z(g, {
+					id: D("pdd_", l, x.id, String(x.version)),
+					tenantId: l,
+					calendarId: x.id,
+					version: x.version,
+					config: x,
+					rulesVersion: A.strategies.version,
+					admission: 0
+				}), a.transactional(async (e) => {
+					let n = await H(e, l, d), a = await G(e, S, C, l, d);
+					if (a) return a;
+					let c = await U(e, _, l, d), u = await U(e, h, l, d), p = await U(e, v, l, d);
+					if (c.length >= A.maxHistoryRows) throw t("limit_exceeded");
+					let E = D("pdd_", l, x.id, String(x.version));
+					if (await e.updateMany(g.tableName, { admission: 0 }, { where: w("id", E) }) !== 1) throw t("invalid_record");
+					let O = (await e.query(T(g).where(w("id", E)).limit(1).descriptor))[0];
+					if (!O || O.tenantId !== l || O.calendarId !== x.id || O.version !== x.version || O.rulesVersion !== A.strategies.version || m(O.config) !== m(x)) throw t("conflict");
+					let k = D("pdl_", l, d, x.id, String(x.version), String(s.dayOrdinal)), j = u.find((e) => e.id === k);
+					if (j) {
+						let n = c.find((e) => e.id === j.operationId);
+						if (!n || n.digest !== C) throw t("invalid_record");
+						let i = W(n, l, d);
+						if (i.after.timezone !== r.timezone) throw t("conflict");
+						return await e.insert(_.tableName, {
+							id: S,
+							tenantId: l,
+							ownerKey: L(l, d),
+							state: "replayed",
+							linkedOperationId: i.operationId,
+							digest: C,
+							receipt: null,
+							at: new Date(o)
+						}), i;
+					}
+					let M = D("pdv_", l, d, x.id, String(x.version)), N = (await e.query(T(y).where(w("id", M)).limit(1).descriptor))[0], P = N ? q(N, l, d, x) : null, F = u.filter((e) => e.calendarId === x.id).sort((e, t) => Number(e.sequence) - Number(t.sequence)).at(-1);
+					if (F && (!P || m(F.after) !== m(P)) || !F && P) throw t("invalid_record");
+					let I = f({
+						calendar: x,
+						previous: P,
+						window: s,
+						at: o
+					}, A.strategies.claimPolicy), R = x.days[I.dayIndex];
+					if (u.length >= A.maxHistoryRows || p.length + R.length > A.maxHistoryRows) throw t("limit_exceeded");
+					let z = i(n.sequence, 0, 2147483646) + 1, B = Object.freeze({
+						operationId: S,
+						claimId: k,
+						calendarId: x.id,
+						dayKey: I.dayKey,
+						after: I,
+						rewardsQueued: R.length,
+						at: o
+					});
+					N ? await e.update(y.tableName, M, {
+						state: I,
+						updatedAt: new Date(o)
+					}) : await e.insert(y.tableName, {
+						id: M,
+						tenantId: l,
+						ownerId: d,
+						ownerKey: L(l, d),
+						calendarId: x.id,
+						version: x.version,
+						state: I,
+						updatedAt: new Date(o)
+					}), await e.insert(h.tableName, {
+						id: k,
+						tenantId: l,
+						ownerId: d,
+						ownerKey: L(l, d),
+						calendarId: x.id,
+						version: x.version,
+						dayOrdinal: I.dayOrdinal,
+						dayKey: I.dayKey,
+						sequence: z,
+						operationId: S,
+						before: P,
+						after: I,
+						profileVersion: r.version,
+						at: new Date(o)
+					}), await e.insert(_.tableName, {
+						id: S,
+						tenantId: l,
+						ownerKey: L(l, d),
+						state: "committed",
+						linkedOperationId: null,
+						digest: C,
+						receipt: B,
+						at: new Date(o)
+					});
+					for (let [t, n] of R.entries()) await e.insert(v.tableName, {
+						id: D("pdr_", k, String(t)),
+						tenantId: l,
+						ownerId: d,
+						ownerKey: L(l, d),
+						claimId: k,
+						operationId: S,
+						reward: n,
+						state: "pending",
+						createdAt: new Date(o),
+						deliveredAt: null,
+						deliveryIntent: null,
+						deliveryDigest: null,
+						deliveryReceipt: null
+					});
+					return await e.update(b.tableName, L(l, d), { sequence: z }), B;
+				});
+			});
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, Y = (r) => {
+		try {
+			let e = n(r), { tenantId: i, ownerId: o } = F(e);
+			return k(async () => {
+				let n = await K(e, i, o), r = N(), s = u({
+					timezone: n.timezone,
+					at: r
+				});
+				return a.transactional(async (e) => {
+					let a = (await e.query(T(b).where(w("id", L(i, o))).forUpdate().limit(1).descriptor))[0];
+					V(a, i, o);
+					let c = await U(e, y, i, o), l = await U(e, h, i, o);
+					return Object.freeze(A.calendars.map((e) => {
+						let a = c.find((t) => t.calendarId === e.id), u = a ? q(a, i, o, e) : null;
+						if (u && (u.timezone !== n.timezone || u.at > r || u.dayOrdinal > s.dayOrdinal)) throw t("conflict");
+						let d = l.filter((t) => t.calendarId === e.id).sort((e, t) => Number(e.sequence) - Number(t.sequence)).at(-1);
+						if (d && (!u || m(d.after) !== m(u)) || !d && u) throw t("invalid_record");
+						let p = u?.dayOrdinal === s.dayOrdinal, h = p ? u : f({
+							calendar: e,
+							previous: u,
+							window: s,
+							at: r
+						}, A.strategies.claimPolicy);
+						return Object.freeze({
+							calendarId: e.id,
+							version: e.version,
+							dayKey: s.dayKey,
+							timezone: n.timezone,
+							from: s.from,
+							until: s.until,
+							observedAt: r,
+							claimed: p,
+							dayIndex: h.dayIndex,
+							streak: p ? h.streak : u?.streak ?? 0,
+							protectionRemaining: h.protectionRemaining,
+							reward: e.days[h.dayIndex]
+						});
+					}));
+				});
+			});
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, X = (n, i) => {
+		try {
+			let e = o(n, [
+				"tenantId",
+				"subjectId",
+				"kind"
+			]), s = r(e.tenantId), c = r(e.subjectId);
+			if (e.kind !== "user" && e.kind !== "guest") throw t("invalid_input");
+			return k(async () => (await B(s, c), a.transactional(async (e) => {
+				if (await e.updateMany(b.tableName, { admission: 0 }, { where: w("id", L(s, c)) }) !== 1) throw t("invalid_record");
+				let n = (await e.query(T(b).where(w("id", L(s, c))).limit(1).descriptor))[0];
+				if (!n || n.tenantId !== s || n.id !== L(s, c) || n.erased !== !1 && n.erased !== !0 || n.erased && n.ownerId !== null || !n.erased && n.ownerId !== c) throw t("invalid_record");
+				let r = await U(e, y, s, c), a = await U(e, h, s, c), o = await U(e, _, s, c), l = await U(e, v, s, c);
+				if (!i) return {
+					calendars: r.map((e) => e.state),
+					claims: a.map((e) => ({
+						before: e.before,
+						after: e.after,
+						profileVersion: e.profileVersion
+					})),
+					requests: o.map((e) => e.receipt),
+					rewards: l.map((e) => ({
+						reward: e.reward,
+						state: e.state,
+						deliveryIntent: e.deliveryIntent,
+						deliveryReceipt: e.deliveryReceipt
+					}))
+				};
+				await e.deleteMany(y.tableName, { where: R(s, c) }), await e.updateMany(h.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					before: null,
+					after: null,
+					profileVersion: null
+				}, { where: R(s, c) }), await e.updateMany(_.tableName, {
+					ownerKey: null,
+					state: "erased",
+					digest: null,
+					receipt: null,
+					linkedOperationId: null
+				}, { where: R(s, c) }), await e.updateMany(v.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					reward: null,
+					state: "erased",
+					deliveredAt: null,
+					deliveryIntent: null,
+					deliveryDigest: null,
+					deliveryReceipt: null
+				}, { where: R(s, c) }), await e.update(b.tableName, L(s, c), {
+					ownerId: null,
+					erased: !0
+				});
+			})));
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, Z = (i, o, s, u) => {
+		try {
+			let e = n(i);
+			I(e);
+			let d = r(o), b = r(s);
+			return k(async () => (await B(d, b), a.transactional(async (e) => {
+				let n = await H(e, d, b), i = await U(e, h, d, b), a = await U(e, _, d, b), o = await U(e, v, d, b), s = [...i].sort((e, t) => Number(e.sequence) - Number(t.sequence)), x = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Set(), C = 0;
+				if (s.length !== n.sequence) throw t("invalid_record");
+				for (let [n, i] of s.entries()) {
+					let s = P(r(i.calendarId)), u = x.get(s.id) ?? null, h = c(i.after, s), _ = (await e.query(T(g).where(w("id", D("pdd_", d, s.id, String(s.version)))).limit(1).descriptor))[0];
+					if (!_ || _.tenantId !== d || _.calendarId !== s.id || _.version !== s.version || _.rulesVersion !== A.strategies.version || m(_.config) !== m(s)) throw t("conflict");
+					let v = a.find((e) => e.id === i.operationId), y = m({
+						tenantId: d,
+						ownerId: b,
+						calendarId: s.id,
+						version: s.version
+					});
+					if (i.sequence !== n + 1 || i.ownerId !== b || i.version !== s.version || i.dayOrdinal !== h.dayOrdinal || i.dayKey !== h.dayKey || i.id !== D("pdl_", d, b, s.id, String(s.version), String(h.dayOrdinal)) || S.has(String(i.id)) || m(i.before) !== m(u) || O(i.at) !== h.at || !v || v.digest !== y || v.linkedOperationId !== null || (r(i.profileVersion), u && (u.dayOrdinal >= h.dayOrdinal || u.timezone !== h.timezone || u.until > h.from || u.at > h.at)) || A.strategies.claimPolicy === l && m(f({
+						calendar: s,
+						previous: u,
+						window: h,
+						at: h.at
+					})) !== m(h)) throw t("invalid_record");
+					let E = W(v, d, b);
+					if (E.claimId !== i.id || m(E.after) !== m(h)) throw t("invalid_record");
+					let k = o.filter((e) => e.claimId === i.id);
+					if (k.length !== E.rewardsQueued) throw t("invalid_record");
+					for (let [e, n] of s.days[h.dayIndex].entries()) {
+						let r = k.find((t) => t.id === D("pdr_", String(i.id), String(e)));
+						if (!r || r.ownerId !== b || r.operationId !== i.operationId || m(r.reward) !== m(n) || O(r.createdAt) !== h.at) throw t("invalid_record");
+						p(r, "daily", m), C++;
+					}
+					S.add(String(i.id)), x.set(s.id, h);
+				}
+				if (C !== o.length) throw t("invalid_record");
+				for (let e of a) if (e.state === "replayed") {
+					let n = a.find((t) => t.id === e.linkedOperationId);
+					if (!n || n.state !== "committed" || e.digest !== n.digest || e.receipt !== null || O(e.at) < O(n.at)) throw t("invalid_record");
+				} else if (e.state !== "committed" || !s.some((t) => t.operationId === e.id)) throw t("invalid_record");
+				let E = await U(e, y, d, b), k = /* @__PURE__ */ new Map();
+				for (let e of E) {
+					let n = P(r(e.calendarId));
+					if (k.has(n.id)) throw t("invalid_record");
+					k.set(n.id, q(e, d, b, n));
+				}
+				let j = k.size === x.size && [...x].every(([e, t]) => m(t) === m(k.get(e) ?? null));
+				if (u && !j) {
+					await e.deleteMany(y.tableName, { where: R(d, b) });
+					for (let [t, n] of x) await e.insert(y.tableName, {
+						id: D("pdv_", d, b, t, String(n.version)),
+						tenantId: d,
+						ownerId: b,
+						ownerKey: L(d, b),
+						calendarId: t,
+						version: n.version,
+						state: n,
+						updatedAt: new Date(n.at)
+					});
+				}
+				return Object.freeze({
+					claims: s.length,
+					rewardRows: C,
+					calendars: x.size,
+					matches: u ? !0 : j
+				});
+			})));
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	};
+	return Object.freeze({
+		claim: J,
+		mine: Y,
+		exportSubject: (e) => X(e, !1),
+		eraseSubject: (e) => x.asVoid(X(e, !0)),
+		auditDaily: (e, t, n) => Z(e, t, n, !1),
+		rebuildDaily: (e, t, n) => Z(e, t, n, !0)
+	});
+};
+export { A as dataStoreLoginCalendars, E as resolveDailyOptions };

package/dist/dailySystem.fixture.js

@@ -0,0 +1,137 @@
+import { grant as e } from "./reward.js";
+import { DailyProfileSource as t, LoginCalendarPort as n, defaultDailyClaimPolicy as r, defaultDailyWindow as i, defineLoginCalendar as a, resolveDailyClaim as o } from "./daily.js";
+import { trackDeclaration as s } from "./track.js";
+import { progressionPlugin as c } from "./plugin.js";
+import { progressionFixture as l } from "./declarationFixtures.js";
+import { Effect as u, Layer as d } from "effect";
+import { ensureTableRegistered as f } from "@voltro/database";
+import { InMemoryDataStore as p } from "@voltro/runtime";
+// src/dailySystem.fixture.ts
+var m = Date.UTC(2026, 9, 10), h = l(), g = a({
+	id: "fixture.daily",
+	days: [[e("gold", 1)], [e("gold", 2)]],
+	streakProtection: 1
+}), _ = Object.freeze({ read: () => u.succeed({
+	timezone: "UTC",
+	version: "fixture.profile"
+}) }), v = {
+	app: {
+		name: "daily-port-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, y = d.effectContext(u.acquireRelease(u.sync(() => c({
+	tracks: [s(h.track)],
+	stats: [{ id: "wins" }],
+	statSources: ["match.finished"],
+	now: () => m,
+	daily: {
+		calendars: [g],
+		profileSource: _,
+		now: () => m
+	}
+})), (e) => u.suspend(() => e.onDeactivate(v))).pipe(u.tap((e) => u.gen(function* () {
+	e.extendSchema.tables.forEach((e) => f(e)), yield* u.promise(() => Promise.resolve(e.bindDataStore(new p())));
+}).pipe(u.orDie)), u.flatMap((e) => d.build(e.services)))), b = d.succeed(t, _), x = {
+	type: "user",
+	id: "a",
+	tenantId: "fixture",
+	kind: "guest"
+}, S = Object.freeze({
+	kind: "port",
+	tag: n,
+	fakeLayer: y,
+	probe: {
+		run: () => u.scoped(u.gen(function* () {
+			let e = yield* n, t = {
+				calendarId: g.id,
+				requestId: "fixture.claim"
+			}, r = yield* e.claim(x, t), i = yield* e.claim(x, t);
+			return {
+				original: r.operationId === i.operationId,
+				rewardsQueued: r.rewardsQueued,
+				calendars: (yield* e.mine(x)).map((e) => ({
+					claimed: e.claimed,
+					streak: e.streak,
+					dayIndex: e.dayIndex
+				}))
+			};
+		}).pipe(u.provide(y))),
+		expected: {
+			original: !0,
+			rewardsQueued: 1,
+			calendars: [{
+				claimed: !0,
+				streak: 1,
+				dayIndex: 0
+			}]
+		}
+	}
+}), C = Object.freeze({
+	kind: "port",
+	tag: t,
+	fakeLayer: b,
+	probe: {
+		run: () => u.scoped(u.gen(function* () {
+			return yield* (yield* t).read(x, {
+				tenantId: "fixture",
+				ownerId: "a"
+			});
+		}).pipe(u.provide(b))),
+		expected: {
+			timezone: "UTC",
+			version: "fixture.profile"
+		}
+	}
+}), w = Object.freeze({
+	calendar: g,
+	previous: null,
+	window: i({
+		timezone: "UTC",
+		at: m
+	}),
+	at: m
+}), T = Object.freeze({
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => u.sync(() => {
+			let e = o(w);
+			return {
+				dayIndex: e.dayIndex,
+				streak: e.streak
+			};
+		}),
+		expected: {
+			dayIndex: 0,
+			streak: 1
+		}
+	},
+	overrideProbe: {
+		run: () => u.sync(() => {
+			let e = o(w, () => ({
+				dayIndex: 1,
+				streak: 5,
+				protectionRemaining: 0,
+				cycle: 0
+			}));
+			return {
+				dayIndex: e.dayIndex,
+				streak: e.streak
+			};
+		}),
+		expected: {
+			dayIndex: 1,
+			streak: 5
+		}
+	}
+});
+export { T as dailyClaimPolicySystemFixture, b as dailyProfileSourceFakeLayer, C as dailyProfileSourceSystemFixture, y as loginCalendarFakeLayer, S as loginCalendarPortSystemFixture };

package/dist/dailyTables.entity.js

@@ -0,0 +1,89 @@
+import { boolean as e, id as t, integer as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+// src/dailyTables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = () => a().maxLength(120).externalId().sensitive("pii"), l = () => a().maxLength(64).nullable().serverOnly(), u = i("_voltro_prog_daily_definitions", {
+	id: t({ prefix: "pdd" }),
+	tenantId: s(),
+	calendarId: a().maxLength(120).safe(),
+	version: n().safe(),
+	config: r().serverOnly(),
+	rulesVersion: a().maxLength(120).safe(),
+	admission: n().serverOnly()
+}).index([
+	"tenantId",
+	"calendarId",
+	"version"
+]), d = i("_voltro_prog_daily_subjects", {
+	id: t({ prefix: "pds" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	erased: e().serverOnly(),
+	sequence: n().serverOnly(),
+	admission: n().serverOnly()
+}).index(["tenantId", "ownerId"]), f = i("_voltro_prog_daily", {
+	id: t({ prefix: "pdv" }),
+	tenantId: s(),
+	ownerId: c(),
+	ownerKey: l(),
+	calendarId: a().maxLength(120).safe(),
+	version: n().safe(),
+	state: r().serverOnly(),
+	updatedAt: o().safe()
+}).index(["tenantId", "ownerKey"]), p = i("_voltro_prog_daily_claims", {
+	id: t({ prefix: "pdl" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: l(),
+	calendarId: a().maxLength(120).safe(),
+	version: n().safe(),
+	dayOrdinal: n().safe(),
+	dayKey: a().maxLength(10).safe(),
+	sequence: n().serverOnly(),
+	operationId: a().maxLength(64).safe(),
+	before: r().nullable().serverOnly(),
+	after: r().nullable().serverOnly(),
+	profileVersion: a().maxLength(120).nullable().serverOnly(),
+	at: o().safe()
+}).index(["tenantId", "ownerKey"]), m = i("_voltro_prog_daily_operations", {
+	id: t({ prefix: "pdo" }),
+	tenantId: s(),
+	ownerKey: l(),
+	state: a().maxLength(16).oneOf([
+		"committed",
+		"replayed",
+		"erased"
+	]).serverOnly(),
+	linkedOperationId: a().maxLength(64).nullable().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	at: o().safe()
+}).index(["tenantId", "ownerKey"]), h = i("_voltro_prog_daily_rewards", {
+	id: t({ prefix: "pdr" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: l(),
+	claimId: a().maxLength(64).safe(),
+	operationId: a().maxLength(64).safe(),
+	reward: r().nullable().serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"delivered",
+		"erased"
+	]).serverOnly(),
+	createdAt: o().safe(),
+	deliveredAt: o().nullable().safe(),
+	deliveryIntent: r().nullable().serverOnly(),
+	deliveryDigest: a().maxLength(64).nullable().serverOnly(),
+	deliveryReceipt: r().nullable().serverOnly()
+}).index([
+	"tenantId",
+	"ownerKey",
+	"state"
+]), g = [
+	u,
+	d,
+	f,
+	p,
+	m,
+	h
+];
+export { p as dailyClaimsTable, u as dailyDefinitionsTable, m as dailyOperationsTable, h as dailyRewardsTable, f as dailyStatesTable, d as dailySubjectsTable, g as dailyTables };