@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/resources.js

@@ -0,0 +1,60 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, object as r, progressValue as i } from "./capture.js";
+import { Context as a, Duration as o } from "effect";
+//#region src/resources.ts
+var s = (a) => {
+	let s = r(a, [
+		"id",
+		"version",
+		"max",
+		"initial",
+		"regenPer",
+		"regenAmount",
+		"regenEveryMs",
+		"refillOffer"
+	]), c = i(s.max), l = i(s.initial ?? c), u = i(s.regenAmount ?? "1");
+	if (c === 0n || l > c || u === 0n || typeof s.regenPer != "string" || s.regenPer.length > 120) throw e("invalid_input");
+	let d;
+	try {
+		d = n(o.toMillis(o.fromInputUnsafe(s.regenPer)), 1, 316224e5);
+	} catch {
+		throw e("invalid_input");
+	}
+	if (s.regenEveryMs !== void 0 && s.regenEveryMs !== d) throw e("invalid_input");
+	return Object.freeze({
+		id: t(s.id),
+		version: n(s.version ?? 1, 1, 1e6),
+		max: String(c),
+		initial: String(l),
+		regenPer: s.regenPer,
+		regenAmount: String(u),
+		regenEveryMs: d,
+		...s.refillOffer === void 0 ? {} : { refillOffer: t(s.refillOffer) }
+	});
+}, c = (e) => {
+	let t = s(e.resource), r = l(e.state, t), i = n(e.at, r.anchorAt, 864e13), a = BigInt(i - r.anchorAt) / BigInt(t.regenEveryMs), o = BigInt(r.value) + a * BigInt(t.regenAmount);
+	return o >= BigInt(t.max) ? Object.freeze({
+		value: t.max,
+		anchorAt: i
+	}) : Object.freeze({
+		value: String(o),
+		anchorAt: r.anchorAt + Number(a) * t.regenEveryMs
+	});
+}, l = (t, a) => {
+	let o = r(t, ["value", "anchorAt"]), s = i(o.value);
+	if (s > BigInt(a.max)) throw e("invalid_record");
+	return Object.freeze({
+		value: String(s),
+		anchorAt: n(o.anchorAt, 0, 864e13)
+	});
+}, u = (t, r = c) => {
+	let i = s(t.resource), a = l(t.state, i), o = n(t.at, a.anchorAt, 864e13), u = l(r(Object.freeze({
+		resource: i,
+		state: a,
+		at: o
+	})), i);
+	if (BigInt(u.value) < BigInt(a.value) || u.anchorAt < a.anchorAt || u.anchorAt > o) throw e("invalid_input");
+	return u;
+}, d = class extends a.Service()("@voltro/RegenResourcePort") {};
+//#endregion
+export { d as RegenResourcePort, l as captureResourceState, c as defaultResourceRegen, s as defineRegenResource, u as resolveResourceRegen };

package/dist/reward-app/schedules/progression.dispatchRewards.cron.tsx

@@ -0,0 +1,19 @@
+import { Effect } from 'effect'
+import { defineSchedule } from '@voltro/runtime'
+import { systemSubject } from '@voltro/protocol'
+import { RewardDeliveryPort, type RewardDispatchCursor } from '@voltro/plugin-progression/delivery'
+import { ProgressionError } from '@voltro/plugin-progression/errors'
+export default defineSchedule({ name: 'progression.dispatchRewards', cron: '* * * * *', timezone: 'UTC', handler: (ctx) => Effect.gen(function* () {
+  const service = yield* RewardDeliveryPort, workflows = ctx.app.workflows
+  const failure = () => new ProgressionError({ code: 'unavailable' })
+  if (!workflows) return yield* Effect.fail(failure())
+  let after: RewardDispatchCursor | undefined, failed = false
+  for (let page = 0; page < 100; page++) {
+    const batch = yield* service.dispatch(systemSubject('progression.reward.dispatch'), { limit: 100, ...(after ? { after } : {}) }, (payload) => workflows.start('progression.deliverReward', payload))
+    failed ||= batch.failed.length > 0
+    if (batch.next === null) { if (failed) return yield* Effect.fail(failure()); return }
+    after = batch.next
+  }
+  // SQL pending rows remain eligible; exceeding a whole-scan budget reports failure.
+  return yield* Effect.fail(failure())
+}) })

package/dist/reward-app/workflows/progression.deliverReward.workflow.server.tsx

@@ -0,0 +1,10 @@
+import { Effect } from 'effect'
+import { step } from '@voltro/workflow'
+import { systemSubject } from '@voltro/protocol'
+import { RewardDeliveryPort, RewardDeliveryReceiptSchema, type RewardDeliveryRequest } from '@voltro/plugin-progression/delivery'
+import { ProgressionError } from '@voltro/plugin-progression/errors'
+export default () => (payload: RewardDeliveryRequest) => Effect.gen(function* () {
+  const service = yield* RewardDeliveryPort
+  return yield* step({ name: 'deliver-accepted-progression-reward', success: RewardDeliveryReceiptSchema, error: ProgressionError,
+    retry: { maxAttempts: 5 }, execute: service.execute(systemSubject('progression.reward.workflow'), payload) })
+})

package/dist/reward-app/workflows/progression.deliverReward.workflow.tsx

@@ -0,0 +1 @@
+export { ProgressionRewardDelivery } from '@voltro/plugin-progression/delivery/workflow'

package/dist/reward.d.ts

@@ -0,0 +1,27 @@
+export declare const captureReward: (input: unknown) => ProgressionReward;
+
+export declare const captureRewards: (input: unknown, max?: number) => readonly ProgressionReward[];
+
+export declare const grant: (currency: string, amount: ProgressValue) => ProgressionReward;
+
+export declare const grantItem: (itemId: string, qty?: number) => ProgressionReward;
+
+export declare type ProgressionReward = {
+    readonly kind: 'currency';
+    readonly currency: string;
+    readonly amount: string;
+} | {
+    readonly kind: 'item';
+    readonly itemId: string;
+    readonly qty: number;
+} | {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly amount: string;
+};
+
+declare type ProgressValue = string | number | bigint;
+
+export declare const xp: (trackId: string, amount: ProgressValue) => ProgressionReward;
+
+export { }

package/dist/reward.js

@@ -0,0 +1,39 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, list as r, object as i, progressValue as a } from "./capture.js";
+//#region src/reward.ts
+var o = (n, r) => {
+	let i = a(r);
+	if (i === 0n) throw e("invalid_reward");
+	return Object.freeze({
+		kind: "currency",
+		currency: t(n),
+		amount: String(i)
+	});
+}, s = (e, r = 1) => Object.freeze({
+	kind: "item",
+	itemId: t(e),
+	qty: n(r, 1, 1e6)
+}), c = (n, r) => {
+	let i = a(r);
+	if (i === 0n) throw e("invalid_reward");
+	return Object.freeze({
+		kind: "xp",
+		trackId: t(n),
+		amount: String(i)
+	});
+}, l = (r) => {
+	let a = i(r, [
+		"kind",
+		"currency",
+		"itemId",
+		"trackId",
+		"amount",
+		"qty"
+	]);
+	if (a.kind === "currency" && Object.keys(a).length === 3) return o(t(a.currency), a.amount);
+	if (a.kind === "item" && Object.keys(a).length === 3) return s(t(a.itemId), n(a.qty, 1, 1e6));
+	if (a.kind === "xp" && Object.keys(a).length === 3) return c(t(a.trackId), a.amount);
+	throw e("invalid_reward");
+}, u = (e, t = 256) => Object.freeze(r(e, t).map(l));
+//#endregion
+export { l as captureReward, u as captureRewards, o as grant, s as grantItem, c as xp };

package/dist/rewardDelivery.d.ts

@@ -0,0 +1,163 @@
+import { Context } from 'effect';
+import { EconomyService } from '@voltro/plugin-economy';
+import { Effect } from 'effect';
+import { InventoryService } from '@voltro/plugin-inventory';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { WorkflowRunHandle } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare interface ApplyStatInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId?: string | null;
+    readonly operator: StatOperator;
+    readonly operand: ProgressValue;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+}
+
+declare interface ApplyXpInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly trackId: string;
+    readonly amount: ProgressValue;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+}
+
+declare interface PlayerStat {
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+    readonly value: string;
+    readonly updatedAt: number;
+}
+
+declare interface PlayerTrack {
+    readonly trackId: string;
+    readonly xp: string;
+    readonly level: number;
+    readonly prestige: number;
+    readonly updatedAt: number | null;
+}
+
+declare type ProgressionChange = {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly xp: string;
+    readonly delta: string;
+    readonly fromLevel: number;
+    readonly toLevel: number;
+} | {
+    readonly kind: 'stat';
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+    readonly value: string;
+    readonly operator: StatOperator;
+};
+
+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 interface ProgressionReceipt {
+    readonly operationId: string;
+    readonly at: number;
+    readonly change: ProgressionChange;
+    readonly rewardsQueued: number;
+}
+
+declare interface ProgressionService {
+    readonly applyXp: (subject: Subject, input: ApplyXpInput) => Effect.Effect<ProgressionReceipt, ProgressionError>;
+    readonly applyStat: (subject: Subject, input: ApplyStatInput) => Effect.Effect<ProgressionReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerTrack[], ProgressionError>;
+    readonly stats: (subject: Subject) => Effect.Effect<readonly PlayerStat[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+declare type ProgressValue = string | number | bigint;
+
+export declare interface RewardDeliveryOptions {
+    /** An explicit app-owned funding account; never a balance/price/credential. */
+    readonly systemAccount: string;
+    readonly economy?: EconomyService | undefined;
+    readonly inventory?: InventoryService | undefined;
+    readonly progression?: ProgressionService | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly version?: string;
+    /** Full replacement must own queue/privacy semantics of its source ports. */
+    readonly service?: RewardDeliveryService | undefined;
+}
+
+export declare class RewardDeliveryPort extends RewardDeliveryPort_base {
+}
+
+declare const RewardDeliveryPort_base: Context.ServiceClass<RewardDeliveryPort, "@voltro/RewardDeliveryPort", RewardDeliveryService>;
+
+export declare interface RewardDeliveryReceipt extends RewardDeliveryRequest {
+    readonly status: 'delivered' | 'erased';
+    readonly outputKind: 'currency' | 'item' | 'xp' | null;
+    readonly externalOperationId: string | null;
+    readonly at: number;
+}
+
+export declare const RewardDeliveryReceiptSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["level", "quest", "achievement", "daily", "pass", "tutorial", "rank"]>;
+    readonly rewardId: Schema.String;
+    readonly status: Schema.Literals<readonly ["delivered", "erased"]>;
+    readonly outputKind: Schema.NullOr<Schema.Literals<readonly ["currency", "item", "xp"]>>;
+    readonly externalOperationId: Schema.NullOr<Schema.String>;
+    readonly at: Schema.Number;
+}>;
+
+export declare interface RewardDeliveryRequest {
+    readonly kind: RewardSourceKind;
+    readonly rewardId: string;
+}
+
+export declare const RewardDeliveryRequestSchema: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["level", "quest", "achievement", "daily", "pass", "tutorial", "rank"]>;
+    readonly rewardId: Schema.String;
+}>;
+
+export declare interface RewardDeliveryService {
+    readonly execute: (subject: Subject, input: RewardDeliveryRequest) => Effect.Effect<RewardDeliveryReceipt, ProgressionError>;
+    readonly dispatch: (subject: Subject, input: RewardDispatchInput, start: (payload: RewardDeliveryRequest) => Promise<WorkflowRunHandle>) => Effect.Effect<RewardDispatchResult, ProgressionError>;
+}
+
+export declare interface RewardDispatchCursor extends RewardDeliveryRequest {
+}
+
+export declare interface RewardDispatchInput {
+    readonly limit: number;
+    readonly after?: RewardDispatchCursor;
+}
+
+export declare interface RewardDispatchResult {
+    readonly submitted: readonly {
+        readonly request: RewardDeliveryRequest;
+        readonly status: WorkflowRunHandle['status'];
+    }[];
+    readonly failed: readonly RewardDeliveryRequest[];
+    readonly next: RewardDispatchCursor | null;
+}
+
+export declare type RewardSourceKind = 'level' | 'quest' | 'achievement' | 'daily' | 'pass' | 'tutorial' | 'rank';
+
+declare const STAT_OPERATORS: readonly ["increment", "max", "min", "set"];
+
+declare type StatOperator = typeof STAT_OPERATORS[number];
+
+export { }

package/dist/rewardDelivery.js

@@ -0,0 +1,38 @@
+import { Context as e, Schema as t } from "effect";
+//#region src/rewardDelivery.ts
+var n = t.String.pipe(t.check(t.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/))), r = t.Struct({
+	kind: t.Literals([
+		"level",
+		"quest",
+		"achievement",
+		"daily",
+		"pass",
+		"tutorial",
+		"rank"
+	]),
+	rewardId: n
+}), i = t.Struct({
+	kind: t.Literals([
+		"level",
+		"quest",
+		"achievement",
+		"daily",
+		"pass",
+		"tutorial",
+		"rank"
+	]),
+	rewardId: n,
+	status: t.Literals(["delivered", "erased"]),
+	outputKind: t.NullOr(t.Literals([
+		"currency",
+		"item",
+		"xp"
+	])),
+	externalOperationId: t.NullOr(n),
+	at: t.Number.pipe(t.check(t.isInt()), t.check(t.isBetween({
+		minimum: 0,
+		maximum: 864e13
+	})))
+}).pipe(t.check(t.makeFilter((e) => e.status === "erased" ? e.outputKind === null && e.externalOperationId === null : e.outputKind !== null && e.externalOperationId !== null))), a = class extends e.Service()("@voltro/RewardDeliveryPort") {};
+//#endregion
+export { a as RewardDeliveryPort, i as RewardDeliveryReceiptSchema, r as RewardDeliveryRequestSchema };