@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/tutorialStore.js

@@ -0,0 +1,495 @@
+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 { captureTutorialEvidence as s, captureTutorialState as c, defaultTutorialStepPolicy as l, defineTutorial as u, initialTutorialState as d, resolveTutorialSkip as f, resolveTutorialStep as p } from "./tutorial.js";
+import { admitRewardDeliveryRecord as m } from "./rewardDeliveryRecord.js";
+import { questHash as h } from "./questStore.js";
+import { tutorialDefinitionsTable as g, tutorialLedgerTable as _, tutorialOperationsTable as v, tutorialRewardsTable as y, tutorialStatesTable as b, tutorialSubjectsTable as x } from "./tutorialTables.entity.js";
+import { Effect as S, Result as C } from "effect";
+import { and as w, eq as T, queryFor as E } from "@voltro/database";
+// src/tutorialStore.ts
+var D = (e) => {
+	let n = o(e, [
+		"definitions",
+		"eventSources",
+		"verifier",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now",
+		"strategies"
+	]), s = o(n.strategies ?? {}, ["stepPolicy", "version"]), c = Object.freeze(a(n.definitions, 64).map((e) => u(e))), d = Object.freeze(a(n.eventSources, 64).map(r)), f = Object.freeze(a(n.allowedServices ?? [], 256).map(r)), p = n.now ?? Date.now, m = s.stepPolicy ?? l, h = n.verifier === void 0 ? void 0 : o(n.verifier);
+	if (!c.length || new Set(c.map((e) => e.id)).size !== c.length || new Set(d).size !== d.length || new Set(f).size !== f.length || h && typeof h.verify != "function" || typeof p != "function" || typeof m != "function" || m !== l && s.version === void 0) throw t("invalid_input");
+	return Object.freeze({
+		definitions: c,
+		eventSources: d,
+		allowedServices: f,
+		now: p,
+		verifier: h ? Object.freeze({ verify: h.verify }) : void 0,
+		maxHistoryRows: i(n.maxHistoryRows ?? 1e4, 1, 1e5),
+		maxPendingRewards: i(n.maxPendingRewards ?? 1e4, 1, 1e5),
+		strategies: Object.freeze({
+			stepPolicy: m,
+			version: r(s.version ?? "default.v1")
+		})
+	});
+}, O = (e, ...t) => e + h(t).slice(0, 56), k = (e) => i(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN, 0, 864e13), A = (n) => S.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), j = (a, l) => {
+	let u = D(l), j = new Map(u.definitions.map((e) => [e.id, e])), M = new Set(u.allowedServices), N = new Set(u.eventSources), 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) => O("pts_", e, t), R = (e, t) => w(T("tenantId", e), T("ownerKey", L(e, t))), z = (e, t, n) => O("ptv_", e, t, n.id, String(n.version)), B = (e) => {
+		let n = o(e, [
+			"tutorialId",
+			"version",
+			"kind",
+			"step",
+			"mode",
+			"source",
+			"originId"
+		]), i = P(r(n.tutorialId));
+		if (n.version !== i.version || n.kind !== "step" && n.kind !== "skip" || n.mode !== "player" && n.mode !== "event" || n.kind === "skip" && (n.step !== null || n.mode !== "player") || n.kind === "step" && !i.steps.includes(r(n.step)) || n.mode === "player" && (n.source !== null || n.originId !== null)) throw t("invalid_record");
+		let a = n.mode === "event" ? r(n.source) : null, s = n.mode === "event" ? r(n.originId) : null;
+		if (a !== null && !N.has(a)) throw t("forbidden");
+		return Object.freeze({
+			tutorialId: i.id,
+			version: i.version,
+			kind: n.kind,
+			step: n.kind === "step" ? r(n.step) : null,
+			mode: n.mode,
+			source: a,
+			originId: s
+		});
+	}, V = (e, t, n) => O("ptk_", e, t, n.tutorialId, String(n.version), n.kind, n.step ?? ""), H = (e, t, n) => h({
+		tenantId: e,
+		ownerId: t,
+		intent: n
+	}), U = async (e, n) => {
+		if ((await a.insertIgnoreWithOutcome(e.tableName, n, { conflictColumns: ["id"] })).outcome !== "inserted" && !(await a.query(E(e).where(T("id", n.id)).limit(1).descriptor))[0]) throw t("unavailable");
+	}, W = (e, t) => U(x, {
+		id: L(e, t),
+		tenantId: e,
+		ownerId: t,
+		erased: !1,
+		sequence: 0,
+		admission: 0
+	}), G = (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);
+		}
+	}, K = async (e, n, r) => {
+		if (await e.updateMany(x.tableName, { admission: 0 }, { where: T("id", L(n, r)) }) !== 1) throw t("invalid_record");
+		let i = (await e.query(E(x).where(T("id", L(n, r))).limit(1).descriptor))[0];
+		if (G(i, n, r), !i) throw t("invalid_record");
+		return i;
+	}, q = async (e, n, r, i) => {
+		let a = n === y ? u.maxPendingRewards : u.maxHistoryRows, o = await e.query(E(n).where(R(r, i)).limit(a + 1).descriptor);
+		if (o.length > a) throw t("limit_exceeded");
+		if (o.some((e) => e.tenantId !== r || e.ownerKey !== L(r, i))) throw t("invalid_record");
+		return o;
+	}, J = async (e, n, r, i) => {
+		let a = O("ptd_", n, r.id, String(r.version));
+		if (i && await e.updateMany(g.tableName, { admission: 0 }, { where: T("id", a) }) !== 1) throw t("invalid_record");
+		let o = (await e.query(E(g).where(T("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.tutorialId !== r.id || o.version !== r.version || o.rulesVersion !== u.strategies.version || h(o.config) !== h(r)) throw t("conflict");
+	}, Y = (e, n, r, i) => {
+		if (e.id !== z(n, r, i) || e.tenantId !== n || e.ownerId !== r || e.ownerKey !== L(n, r) || e.tutorialId !== i.id || e.version !== i.version) throw t("invalid_record");
+		let a = c(e.state, i);
+		if (a.updatedAt !== k(e.updatedAt)) throw t("invalid_record");
+		return a;
+	}, X = (e) => {
+		let n = o(e.receipt, [
+			"operationId",
+			"kind",
+			"step",
+			"after",
+			"rewardsQueued",
+			"at"
+		]), i = B(e.intent), a = P(i.tutorialId), s = c(n.after, a);
+		if (e.state !== "committed" || e.linkedOperationId !== null || n.operationId !== e.id || n.kind !== i.kind || n.step !== i.step || n.at !== k(e.at) || n.at !== s.updatedAt || n.kind === "step" && s.completedSteps.at(-1) !== n.step || n.kind === "skip" && !s.skipped) throw t("invalid_record");
+		let l = s.completed && (!s.skipped || a.rewardOnSkip) ? a.reward.length : 0;
+		if (n.rewardsQueued !== l) throw t("invalid_record");
+		return Object.freeze({
+			operationId: r(e.id),
+			kind: i.kind,
+			step: i.step,
+			after: s,
+			rewardsQueued: l,
+			at: s.updatedAt
+		});
+	}, ee = async (e, n, r, i, a) => {
+		let o = (await e.query(E(v).where(T("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 !== H(i, a, r) || h(B(o.intent)) !== h(r)) throw t("conflict");
+		if (await J(e, i, P(r.tutorialId), !1), o.state === "committed") return X(o);
+		if (o.state !== "replayed" || o.receipt !== null || typeof o.linkedOperationId != "string") throw t("invalid_record");
+		let s = (await e.query(E(v).where(T("id", o.linkedOperationId)).limit(1).descriptor))[0];
+		if (!s || s.tenantId !== i || s.ownerKey !== L(i, a) || V(i, a, B(s.intent)) !== V(i, a, r)) throw t("invalid_record");
+		return X(s);
+	}, Z = (c, l, m, w) => {
+		try {
+			let e = n(c), D = o(l, w === "skip" ? ["tutorialId", "requestId"] : m === "player" ? [
+				"tutorialId",
+				"step",
+				"requestId"
+			] : [
+				"tenantId",
+				"ownerId",
+				"tutorialId",
+				"step",
+				"requestId",
+				"source",
+				"originId"
+			]), { tenantId: k, ownerId: j } = m === "player" ? F(e) : (I(e), {
+				tenantId: r(D.tenantId),
+				ownerId: r(D.ownerId)
+			}), M = P(r(D.tutorialId)), R = r(D.requestId), G = B({
+				tutorialId: M.id,
+				version: M.version,
+				kind: w,
+				step: w === "skip" ? null : D.step,
+				mode: m,
+				source: m === "player" ? null : D.source,
+				originId: m === "player" ? null : D.originId
+			}), Z = O("pto_", k, j, R);
+			return A(async () => {
+				await W(k, j);
+				let c = async (e) => {
+					await K(e, k, j);
+					let n = await ee(e, Z, G, k, j);
+					if (n) return n;
+					let i = (await q(e, _, k, j)).find((e) => e.claimKey === V(k, j, G));
+					if (!i) return;
+					let a = (await e.query(E(v).where(T("id", r(i.operationId))).limit(1).descriptor))[0];
+					if (!a || a.tenantId !== k || a.ownerKey !== L(k, j) || V(k, j, B(a.intent)) !== V(k, j, G)) throw t("invalid_record");
+					await J(e, k, M, !1);
+					let o = X(a);
+					if ((await q(e, v, k, j)).length >= u.maxHistoryRows) throw t("limit_exceeded");
+					return await e.insert(v.tableName, {
+						id: Z,
+						tenantId: k,
+						ownerKey: L(k, j),
+						state: "replayed",
+						linkedOperationId: o.operationId,
+						intent: G,
+						digest: H(k, j, G),
+						receipt: null,
+						at: new Date(o.at)
+					}), o;
+				}, l = await a.transactional(c);
+				if (l) return l;
+				let D = null;
+				if (w === "step" && m === "player") {
+					if (!u.verifier) throw t("unavailable");
+					let r = await S.runPromise(S.result(u.verifier.verify(e, {
+						tenantId: k,
+						ownerId: j,
+						tutorialId: M.id,
+						version: M.version,
+						step: G.step,
+						requestId: R
+					})));
+					if (C.isFailure(r)) throw r.failure;
+					D = n(r.success);
+				}
+				let A = i(u.now(), 0, 864e13);
+				if (w === "step" && (D = s(m === "event" ? {
+					source: G.source,
+					originId: G.originId,
+					version: "trusted.event.v1",
+					from: A,
+					until: A + 1
+				} : D, A)), D && !N.has(D.source)) throw t("forbidden");
+				return await U(g, {
+					id: O("ptd_", k, M.id, String(M.version)),
+					tenantId: k,
+					tutorialId: M.id,
+					version: M.version,
+					config: M,
+					rulesVersion: u.strategies.version,
+					admission: 0
+				}), a.transactional(async (e) => {
+					let n = await c(e);
+					if (n) return n;
+					let r = await K(e, k, j);
+					await J(e, k, M, !0);
+					let a = await q(e, _, k, j), s = await q(e, v, k, j), l = await q(e, y, k, j);
+					if (a.length >= u.maxHistoryRows || s.length >= u.maxHistoryRows) throw t("limit_exceeded");
+					if (D && a.some((e) => {
+						let t = o(e.intent);
+						if (t.tutorialId !== M.id || t.kind !== "step") return !1;
+						let n = o(t.evidence);
+						return n.source === D.source && n.originId === D.originId;
+					})) throw t("conflict");
+					let m = z(k, j, M), g = (await e.query(E(b).where(T("id", m)).limit(1).descriptor))[0], S = g ? Y(g, k, j, M) : d(M), C = a.filter((e) => e.tutorialId === M.id).sort((e, t) => Number(e.sequence) - Number(t.sequence)).at(-1);
+					if (C && (!g || h(C.after) !== h(S)) || !C && g) throw t("invalid_record");
+					let N = w === "skip" ? f(M, S, A) : p({
+						tutorial: M,
+						before: S,
+						step: G.step,
+						evidence: D,
+						at: A
+					}, u.strategies.stepPolicy), P = N.completed && (!N.skipped || M.rewardOnSkip) ? M.reward.length : 0;
+					if (l.length + P > u.maxPendingRewards) throw t("limit_exceeded");
+					let F = i(r.sequence, 0, 2147483646) + 1, I = Object.freeze({
+						operationId: Z,
+						kind: w,
+						step: G.step,
+						after: N,
+						rewardsQueued: P,
+						at: A
+					});
+					if (g ? await e.update(b.tableName, m, {
+						state: N,
+						updatedAt: new Date(A)
+					}) : await e.insert(b.tableName, {
+						id: m,
+						tenantId: k,
+						ownerId: j,
+						ownerKey: L(k, j),
+						tutorialId: M.id,
+						version: M.version,
+						state: N,
+						updatedAt: new Date(A)
+					}), await e.insert(_.tableName, {
+						id: O("ptl_", Z),
+						tenantId: k,
+						ownerId: j,
+						ownerKey: L(k, j),
+						tutorialId: M.id,
+						version: M.version,
+						sequence: F,
+						operationId: Z,
+						claimKey: V(k, j, G),
+						intent: {
+							...G,
+							evidence: D
+						},
+						before: S,
+						after: N,
+						at: new Date(A)
+					}), await e.insert(v.tableName, {
+						id: Z,
+						tenantId: k,
+						ownerKey: L(k, j),
+						state: "committed",
+						linkedOperationId: null,
+						intent: G,
+						digest: H(k, j, G),
+						receipt: I,
+						at: new Date(A)
+					}), P) for (let [t, n] of M.reward.entries()) await e.insert(y.tableName, {
+						id: O("ptr_", k, j, M.id, String(M.version), String(t)),
+						tenantId: k,
+						ownerId: j,
+						ownerKey: L(k, j),
+						tutorialId: M.id,
+						version: M.version,
+						operationId: Z,
+						reward: n,
+						state: "pending",
+						createdAt: new Date(A),
+						deliveredAt: null,
+						deliveryIntent: null,
+						deliveryDigest: null,
+						deliveryReceipt: null
+					});
+					return await e.update(x.tableName, L(k, j), { sequence: F }), I;
+				});
+			});
+		} catch (n) {
+			return S.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, te = (r) => {
+		try {
+			let { tenantId: e, ownerId: i } = F(n(r));
+			return A(async () => a.transactional(async (n) => {
+				let r = (await n.query(E(x).where(T("id", L(e, i))).forUpdate().limit(1).descriptor))[0];
+				G(r, e, i);
+				let a = await q(n, b, e, i), o = await q(n, _, e, i);
+				return Object.freeze(u.definitions.map((n) => {
+					let r = a.find((e) => e.tutorialId === n.id), s = r ? Y(r, e, i, n) : d(n), c = o.filter((e) => e.tutorialId === n.id).sort((e, t) => Number(e.sequence) - Number(t.sequence)).at(-1);
+					if (c && (!r || h(c.after) !== h(s)) || !c && r) throw t("invalid_record");
+					return Object.freeze({
+						...s,
+						nextStep: s.completed ? null : n.steps[s.completedSteps.length],
+						skippable: n.skippable,
+						hints: n.hints
+					});
+				}));
+			}));
+		} catch (n) {
+			return S.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, Q = (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 A(async () => (await W(s, c), a.transactional(async (e) => {
+				if (await e.updateMany(x.tableName, { admission: 0 }, { where: T("id", L(s, c)) }) !== 1) throw t("invalid_record");
+				let n = (await e.query(E(x).where(T("id", L(s, c))).limit(1).descriptor))[0];
+				if (!n || n.tenantId !== s || typeof n.erased != "boolean" || n.erased && n.ownerId !== null || !n.erased && n.ownerId !== c) throw t("invalid_record");
+				let r = await q(e, b, s, c), a = await q(e, _, s, c), o = await q(e, v, s, c), l = await q(e, y, s, c);
+				if (!i) return {
+					tutorials: r.map((e) => e.state),
+					history: a.map((e) => ({
+						intent: e.intent,
+						before: e.before,
+						after: e.after
+					})),
+					requests: o.map((e) => ({
+						intent: e.intent,
+						receipt: e.receipt
+					})),
+					rewards: l.map((e) => ({
+						reward: e.reward,
+						state: e.state,
+						deliveryIntent: e.deliveryIntent,
+						deliveryReceipt: e.deliveryReceipt
+					}))
+				};
+				await e.deleteMany(b.tableName, { where: R(s, c) }), await e.updateMany(_.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					intent: null,
+					before: null,
+					after: null
+				}, { where: R(s, c) }), await e.updateMany(v.tableName, {
+					ownerKey: null,
+					state: "erased",
+					linkedOperationId: null,
+					intent: null,
+					digest: null,
+					receipt: null
+				}, { where: R(s, c) }), await e.updateMany(y.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					reward: null,
+					state: "erased",
+					deliveredAt: null,
+					deliveryIntent: null,
+					deliveryDigest: null,
+					deliveryReceipt: null
+				}, { where: R(s, c) }), await e.update(x.tableName, L(s, c), {
+					ownerId: null,
+					erased: !0
+				});
+			})));
+		} catch (n) {
+			return S.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, $ = (i, c, l, u) => {
+		try {
+			I(n(i));
+			let e = r(c), g = r(l);
+			return A(async () => (await W(e, g), a.transactional(async (n) => {
+				let i = await K(n, e, g), a = await q(n, _, e, g), c = await q(n, v, e, g), l = await q(n, y, e, g), x = [...a].sort((e, t) => Number(e.sequence) - Number(t.sequence)), S = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Set(), w = /* @__PURE__ */ new Set(), T = 0;
+				if (x.length !== i.sequence) throw t("invalid_record");
+				for (let [i, a] of x.entries()) {
+					let u = P(r(a.tutorialId)), { evidence: _, ...v } = o(a.intent, [
+						"tutorialId",
+						"version",
+						"kind",
+						"step",
+						"mode",
+						"source",
+						"originId",
+						"evidence"
+					]), y = B(v), b = k(a.at), x = S.get(u.id) ?? d(u), E = c.find((e) => e.id === a.operationId);
+					if (await J(n, e, u, !1), a.sequence !== i + 1 || a.id !== O("ptl_", r(a.operationId)) || a.ownerId !== g || a.version !== u.version || y.tutorialId !== u.id || a.claimKey !== V(e, g, y) || w.has(String(a.claimKey)) || h(a.before) !== h(x) || !E || E.digest !== H(e, g, y) || h(B(E.intent)) !== h(y)) throw t("invalid_record");
+					let D;
+					if (y.kind === "step") {
+						let e = s(_, b), n = O("pti_", u.id, e.source, e.originId);
+						if (!N.has(e.source) || C.has(n) || y.mode === "event" && (y.source !== e.source || y.originId !== e.originId || e.version !== "trusted.event.v1")) throw t("invalid_record");
+						D = p({
+							tutorial: u,
+							before: x,
+							step: y.step,
+							evidence: e,
+							at: b
+						}), C.add(n);
+					} else {
+						if (_ !== null) throw t("invalid_record");
+						D = f(u, x, b);
+					}
+					let A = X(E);
+					if (h(a.after) !== h(D) || h(A.after) !== h(D) || A.at !== b) throw t("invalid_record");
+					let j = l.filter((e) => e.operationId === E.id);
+					if (j.length !== A.rewardsQueued) throw t("invalid_record");
+					if (A.rewardsQueued) for (let [n, r] of u.reward.entries()) {
+						let i = j.find((t) => t.id === O("ptr_", e, g, u.id, String(u.version), String(n)));
+						if (!i || i.ownerId !== g || i.tutorialId !== u.id || i.version !== u.version || h(i.reward) !== h(r) || k(i.createdAt) !== b) throw t("invalid_record");
+						m(i, "tutorial", h), T++;
+					}
+					w.add(String(a.claimKey)), S.set(u.id, D);
+				}
+				if (l.length !== T) throw t("invalid_record");
+				for (let n of c) {
+					let r = B(n.intent);
+					if (n.digest !== H(e, g, r)) throw t("invalid_record");
+					if (n.state === "replayed") {
+						let i = c.find((e) => e.id === n.linkedOperationId);
+						if (!i || i.state !== "committed" || n.receipt !== null || V(e, g, r) !== V(e, g, B(i.intent)) || k(n.at) !== k(i.at)) throw t("invalid_record");
+					} else if (n.state !== "committed" || !x.some((e) => e.operationId === n.id)) throw t("invalid_record");
+				}
+				let E = await q(n, b, e, g), D = /* @__PURE__ */ new Map();
+				for (let n of E) {
+					let i = P(r(n.tutorialId));
+					if (D.has(i.id)) throw t("invalid_record");
+					D.set(i.id, Y(n, e, g, i));
+				}
+				let A = D.size === S.size && [...S].every(([e, t]) => h(t) === h(D.get(e) ?? null));
+				if (u && !A) {
+					await n.deleteMany(b.tableName, { where: R(e, g) });
+					for (let [t, r] of S) await n.insert(b.tableName, {
+						id: z(e, g, P(t)),
+						tenantId: e,
+						ownerId: g,
+						ownerKey: L(e, g),
+						tutorialId: t,
+						version: r.version,
+						state: r,
+						updatedAt: new Date(r.updatedAt)
+					});
+				}
+				return Object.freeze({
+					operations: x.length,
+					tutorials: S.size,
+					rewardRows: T,
+					matches: u ? !0 : A
+				});
+			})));
+		} catch (n) {
+			return S.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	};
+	return Object.freeze({
+		completeStep: (e, t) => Z(e, t, "player", "step"),
+		record: (e, t) => Z(e, t, "event", "step"),
+		skip: (e, t) => Z(e, t, "player", "skip"),
+		mine: te,
+		exportSubject: (e) => Q(e, !1),
+		eraseSubject: (e) => S.asVoid(Q(e, !0)),
+		auditTutorials: (e, t, n) => $(e, t, n, !1),
+		rebuildTutorials: (e, t, n) => $(e, t, n, !0)
+	});
+};
+export { j as dataStoreTutorials, D as resolveTutorialOptions };

package/dist/tutorialSystem.fixture.js

@@ -0,0 +1,99 @@
+import { grant as e } from "./reward.js";
+import { TutorialPort as t, defaultTutorialStepPolicy as n, resolveTutorialStep as r } from "./tutorial.js";
+import { trackDeclaration as i } from "./track.js";
+import { progressionPlugin as a } from "./plugin.js";
+import { progressionFixture as o, tutorialFixture as s } from "./declarationFixtures.js";
+import { Effect as c, Layer as l, Result as u } from "effect";
+import { systemSubject as d } from "@voltro/protocol";
+import { ensureTableRegistered as f } from "@voltro/database";
+import { InMemoryDataStore as p } from "@voltro/runtime";
+// src/tutorialSystem.fixture.ts
+var m = Date.UTC(2026, 9, 10), h = o(), g = s(), _ = {
+	app: {
+		name: "tutorial-port-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, v = l.effectContext(c.acquireRelease(c.sync(() => a({
+	tracks: [i(h.track)],
+	stats: [{ id: "wins" }],
+	statSources: ["match.finished"],
+	now: () => m,
+	tutorials: {
+		definitions: [{
+			id: "fixture.onboarding",
+			steps: ["move", "shoot"],
+			reward: [e("gold", 5)]
+		}],
+		eventSources: ["match.finished"],
+		now: () => m
+	}
+})), (e) => c.suspend(() => e.onDeactivate(_))).pipe(c.tap((e) => c.gen(function* () {
+	e.extendSchema.tables.forEach((e) => f(e)), yield* c.promise(() => Promise.resolve(e.bindDataStore(new p())));
+}).pipe(c.orDie)), c.flatMap((e) => l.build(e.services)))), y = {
+	type: "user",
+	id: "a",
+	tenantId: "fixture",
+	kind: "guest"
+}, b = d("tutorial.system.fixture"), x = (e) => ({
+	tenantId: "fixture",
+	ownerId: "a",
+	tutorialId: "fixture.onboarding",
+	step: e,
+	requestId: "fixture." + e,
+	source: "match.finished",
+	originId: "fixture." + e
+}), S = Object.freeze({
+	kind: "port",
+	tag: t,
+	fakeLayer: v,
+	probe: {
+		run: () => c.scoped(c.gen(function* () {
+			let e = yield* t, n = yield* e.record(b, x("move")), r = yield* e.record(b, x("move")), i = yield* e.record(b, x("shoot"));
+			return {
+				original: n.operationId === r.operationId,
+				completed: i.after.completed,
+				rewardsQueued: i.rewardsQueued,
+				tutorials: (yield* e.mine(y)).map((e) => ({
+					completedSteps: e.completedSteps,
+					nextStep: e.nextStep
+				}))
+			};
+		}).pipe(c.provide(v))),
+		expected: {
+			original: !0,
+			completed: !0,
+			rewardsQueued: 1,
+			tutorials: [{
+				completedSteps: ["move", "shoot"],
+				nextStep: null
+			}]
+		}
+	}
+}), C = (e) => c.sync(() => u.try({
+	try: e,
+	catch: (e) => e.code ?? "unexpected"
+})).pipe(c.map(u.match({
+	onFailure: (e) => e,
+	onSuccess: () => "accepted"
+}))), w = Object.freeze({
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => c.sync(() => r(g.stepPolicy).completedSteps),
+		expected: ["move"]
+	},
+	overrideProbe: {
+		run: () => C(() => r(g.stepPolicy, () => !1)),
+		expected: "forbidden"
+	}
+});
+export { v as tutorialFakeLayer, S as tutorialPortSystemFixture, w as tutorialStepPolicySystemFixture };

package/dist/tutorialTables.entity.js

@@ -0,0 +1,90 @@
+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/tutorialTables.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_tutorial_definitions", {
+	id: t({ prefix: "ptd" }),
+	tenantId: s(),
+	tutorialId: a().maxLength(120).safe(),
+	version: n().safe(),
+	config: r().serverOnly(),
+	rulesVersion: a().maxLength(120).safe(),
+	admission: n().serverOnly()
+}).index("voltro_prog_tutorial_definitions_version_idx", [
+	"tenantId",
+	"tutorialId",
+	"version"
+]), d = i("_voltro_prog_tutorial_subjects", {
+	id: t({ prefix: "pts" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	erased: e().serverOnly(),
+	sequence: n().serverOnly(),
+	admission: n().serverOnly()
+}).index(["tenantId", "ownerId"]), f = i("_voltro_prog_tutorial", {
+	id: t({ prefix: "ptv" }),
+	tenantId: s(),
+	ownerId: c(),
+	ownerKey: l(),
+	tutorialId: a().maxLength(120).safe(),
+	version: n().safe(),
+	state: r().serverOnly(),
+	updatedAt: o().safe()
+}).index(["tenantId", "ownerKey"]), p = i("_voltro_prog_tutorial_ledger", {
+	id: t({ prefix: "ptl" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: l(),
+	tutorialId: a().maxLength(120).safe(),
+	version: n().safe(),
+	sequence: n().serverOnly(),
+	operationId: a().maxLength(64).safe(),
+	claimKey: a().maxLength(64).serverOnly(),
+	intent: r().nullable().serverOnly(),
+	before: r().nullable().serverOnly(),
+	after: r().nullable().serverOnly(),
+	at: o().safe()
+}).index(["tenantId", "ownerKey"]), m = i("_voltro_prog_tutorial_operations", {
+	id: t({ prefix: "pto" }),
+	tenantId: s(),
+	ownerKey: l(),
+	state: a().maxLength(16).oneOf([
+		"committed",
+		"replayed",
+		"erased"
+	]).serverOnly(),
+	linkedOperationId: a().maxLength(64).nullable().serverOnly(),
+	intent: r().nullable().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	at: o().safe()
+}).index(["tenantId", "ownerKey"]), h = i("_voltro_prog_tutorial_rewards", {
+	id: t({ prefix: "ptr" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: l(),
+	tutorialId: a().maxLength(120).safe(),
+	version: n().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 { u as tutorialDefinitionsTable, p as tutorialLedgerTable, m as tutorialOperationsTable, h as tutorialRewardsTable, f as tutorialStatesTable, d as tutorialSubjectsTable, g as tutorialTables };