@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/cmsQuests.js

@@ -0,0 +1,83 @@
+import { ProgressionError as e, progressionError as t } from "./errors.js";
+import { identifier as n, integer as r, object as i } from "./capture.js";
+import { defineQuestPool as a } from "./quests.js";
+import { questHash as o } from "./questStore.js";
+import { Effect as s } from "effect";
+import { Schema as c, cmsContext as l, contentTypeToEntities as u, defineContentType as d } from "@voltro/cms";
+//#region src/cmsQuests.ts
+var f = d({
+	name: "quest_pool",
+	displayName: "Quest pool",
+	pluralName: "Quest pools",
+	fields: {
+		poolId: c.String.pipe(c.maxLength(120), c.pattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/), c.unique()),
+		version: c.Number,
+		definitionJson: c.String.pipe(c.maxLength(65536))
+	},
+	list: {
+		columns: ["poolId", "version"],
+		defaultSort: {
+			field: "poolId",
+			dir: "asc"
+		}
+	}
+}), p = u(f), m = (c, u) => {
+	let d = i(u, [
+		"site",
+		"environments",
+		"maxPools"
+	]), p = i(d.environments), m = (e) => {
+		let r = n(e);
+		if (r.length > 64) throw t("invalid_input");
+		return r;
+	}, h = m(d.site), g = Object.freeze(Object.fromEntries(Object.entries(p).map(([e, t]) => [n(e), m(t)]))), _ = r(d.maxPools ?? 64, 1, 64);
+	if (Object.keys(g).length < 1 || Object.keys(g).length > 32) throw t("invalid_input");
+	return Object.freeze({ read: (r) => {
+		try {
+			let u = i(r, [
+				"tenantId",
+				"channel",
+				"locale"
+			]), d = n(u.tenantId), p = n(u.channel), v = m(u.locale), y = g[p];
+			if (!y) throw t("not_found");
+			let b = Object.freeze({
+				site: h,
+				environment: y,
+				locale: v
+			});
+			return s.tryPromise({
+				try: async () => {
+					let e = await l(c, [f], { scope: b }).contentType("quest_pool").where("tenantId", "=", d).orderBy("poolId", "asc").limit(_ + 1).all();
+					if (e.length > _) throw t("limit_exceeded");
+					let n = Object.freeze(e.map((e) => {
+						if (e.tenantId !== d || e.site !== h || e.environment !== y || e.locale !== v || e.status !== "published" || typeof e.definitionJson != "string" || e.definitionJson.length > 65536) throw t("invalid_record");
+						let n;
+						try {
+							n = JSON.parse(e.definitionJson);
+						} catch {
+							throw t("invalid_record");
+						}
+						let r = a(n);
+						if (r.id !== e.poolId || r.version !== e.version) throw t("invalid_record");
+						return r;
+					}).sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id)));
+					if (new Set(n.map((e) => e.id)).size !== n.length) throw t("conflict");
+					return Object.freeze({
+						revision: o({
+							site: h,
+							environment: y,
+							locale: v,
+							pools: n
+						}),
+						pools: n
+					});
+				},
+				catch: (n) => n instanceof e ? n : t("unavailable")
+			});
+		} catch (n) {
+			return s.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	} });
+};
+//#endregion
+export { m as cmsQuestSource, p as progressionQuestContentTables, f as progressionQuestContentType };

package/dist/components.d.ts

@@ -0,0 +1,172 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { ReactNode } from 'react';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+/** Exact decimal text plus bounded display ratios; client state never grants an unlock. */
+export declare function AchievementCard({ achievement, title, locale }: AchievementCardProps): ReactNode;
+
+export declare interface AchievementCardProps {
+    readonly achievement: PlayerAchievement;
+    readonly title?: ReactNode | undefined;
+    readonly locale?: string | undefined;
+}
+
+/** Mount in a verified owner/API context; the opaque scope changes with that identity. */
+export declare function AchievementList(props: AchievementListProps): ReactNode;
+
+export declare interface AchievementListProps {
+    readonly api?: string;
+    readonly invocationScope: string;
+    readonly locale?: string;
+    readonly renderTitle?: (achievement: PlayerAchievement) => ReactNode;
+}
+
+export declare const browserQuestRerollJournal: QuestRerollJournal;
+
+/** Only one bounded request/receipt per verified scope persists; no credentials or quest content. */
+export declare const makeQuestRerollJournal: (ports: QuestRerollJournalPorts) => QuestRerollJournal;
+
+/** The wire shape decoded below; optional platform IDs may be present-but-undefined. */
+declare type PlayerAchievement = typeof PlayerAchievementSchema.Type;
+
+declare const PlayerAchievementSchema: Schema.Struct<{
+    readonly achievementId: Schema.String;
+    readonly version: Schema.Number;
+    readonly tierId: Schema.String;
+    readonly unlocked: Schema.Boolean;
+    readonly unlockedAt: Schema.NullOr<Schema.Number>;
+    readonly progress: Schema.$Array<Schema.Struct<{
+        readonly stat: Schema.String;
+        readonly period: Schema.Literals<readonly ["lifetime", "season"]>;
+        readonly seasonId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.String;
+        readonly target: Schema.String;
+        readonly met: Schema.Boolean;
+    }>>;
+    readonly platform: Schema.NullOr<Schema.Struct<{
+        readonly steam: Schema.optional<Schema.String>;
+        readonly gameCenter: Schema.optional<Schema.String>;
+        readonly playGames: Schema.optional<Schema.String>;
+    }>>;
+}>;
+
+/** The wire shape decoded from the quest query. */
+declare type PlayerQuest = typeof PlayerQuestSchema.Type;
+
+declare const PlayerQuestSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly poolId: Schema.String;
+    readonly windowId: Schema.String;
+    readonly quest: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly titleKey: Schema.optional<Schema.String>;
+        readonly objectives: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly stat: Schema.String;
+            readonly target: Schema.Number;
+        }>, Schema.Struct<{
+            readonly event: Schema.String;
+            readonly target: Schema.Number;
+            readonly where: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>>;
+        }>]>>;
+        readonly reward: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"currency">;
+            readonly currency: Schema.String;
+            readonly amount: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"item">;
+            readonly itemId: Schema.String;
+            readonly qty: Schema.Number;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"xp">;
+            readonly trackId: Schema.String;
+            readonly amount: Schema.String;
+        }>]>>;
+    }>;
+    readonly progress: Schema.$Array<Schema.Number>;
+    readonly state: Schema.Literals<readonly ["active", "completed"]>;
+    readonly assignedAt: Schema.Number;
+    readonly expiresAt: Schema.Number;
+    readonly rerollsUsed: Schema.Number;
+    readonly rerollsAllowed: Schema.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>;
+
+/** Semantic, ejectable markup in the UI kit's existing unstyled component system. */
+export declare function QuestCard({ quest, now, title, locale, pending, blocked, error, onReroll }: QuestCardProps): ReactNode;
+
+export declare interface QuestCardProps {
+    readonly quest: PlayerQuest;
+    readonly now: number;
+    readonly title?: ReactNode | undefined;
+    readonly locale?: string | undefined;
+    readonly pending?: boolean | undefined;
+    readonly blocked?: boolean | undefined;
+    readonly error?: boolean | undefined;
+    readonly onReroll?: (() => Promise<void>) | undefined;
+}
+
+/** Own live Quest query plus durable, scope-locked reroll intentions; no optimistic progress or rewards. */
+export declare function QuestList(props: QuestListProps): ReactNode;
+
+export declare interface QuestListProps {
+    readonly api?: string;
+    /** Opaque, stable verified app/API/credential-owner scope; remount on identity changes. Never a secret. */
+    readonly invocationScope: string;
+    readonly locale?: string;
+    readonly journal?: QuestRerollJournal;
+    readonly renderTitle?: (quest: PlayerQuest) => ReactNode;
+}
+
+declare const QuestReceiptSchema: Schema.Struct<{
+    readonly operationId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["assign", "record", "reroll"]>;
+    readonly assignmentIds: Schema.$Array<Schema.String>;
+    readonly completedIds: Schema.$Array<Schema.String>;
+    readonly rewardsQueued: Schema.Number;
+    readonly at: Schema.Number;
+}>;
+
+export declare type QuestRerollIntent = typeof questsRerollDescriptor.input.Type;
+
+export declare interface QuestRerollJournal {
+    /** Exclusive scope lock; write identity durably before invoking transport. */
+    readonly pending: (scope: string) => boolean;
+    readonly recover: (scope: string, send: (input: QuestRerollIntent) => Promise<QuestRerollReceipt>) => Promise<QuestRerollReceipt | undefined>;
+    readonly run: (scope: string, input: Omit<QuestRerollIntent, 'requestId'>, send: (input: QuestRerollIntent) => Promise<QuestRerollReceipt>) => Promise<QuestRerollReceipt>;
+}
+
+export declare interface QuestRerollJournalPorts {
+    readonly storage: QuestRerollJournalStorage;
+    readonly exclusive: <A>(name: string, run: () => Promise<A>) => Promise<A>;
+    readonly requestId: () => string;
+}
+
+export declare interface QuestRerollJournalStorage {
+    readonly getItem: (key: string) => string | null;
+    readonly setItem: (key: string, value: string) => void;
+}
+
+export declare type QuestRerollReceipt = typeof QuestReceiptSchema.Type;
+
+declare const questsRerollDescriptor: ActionProcedureDescriptor<"quests.reroll", Schema.Struct<{
+    readonly poolId: Schema.String;
+    readonly windowId: Schema.String;
+    readonly assignmentId: Schema.String;
+    readonly requestId: Schema.String;
+}>, Schema.Struct<{
+    readonly operationId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["assign", "record", "reroll"]>;
+    readonly assignmentIds: Schema.$Array<Schema.String>;
+    readonly completedIds: Schema.$Array<Schema.String>;
+    readonly rewardsQueued: Schema.Number;
+    readonly at: Schema.Number;
+}>, typeof ProgressionError>;
+
+export { }

package/dist/components.js

@@ -0,0 +1,4 @@
+import { browserQuestRerollJournal as e, makeQuestRerollJournal as t } from "./questRerollJournal.js";
+import { QuestCard as n, QuestList as r } from "./questComponents.js";
+import { AchievementCard as i, AchievementList as a } from "./achievementComponents.js";
+export { i as AchievementCard, a as AchievementList, n as QuestCard, r as QuestList, e as browserQuestRerollJournal, t as makeQuestRerollJournal };

package/dist/curve.d.ts

@@ -0,0 +1,27 @@
+export declare const defaultXpCurve: XpCurve;
+
+export declare const explicitLevelCurve: (thresholds: readonly ProgressValue[]) => LevelCurve;
+
+export declare interface LevelCurve {
+    readonly thresholds: readonly string[];
+}
+
+/** Recurrence rounds the next per-level requirement up using an exact decimal ratio. */
+export declare const levelCurve: (input: {
+    readonly base: ProgressValue;
+    readonly growth: number;
+    readonly maxLevel: number;
+}) => LevelCurve;
+
+declare type ProgressValue = string | number | bigint;
+
+export declare const resolveXpCurve: (xp: ProgressValue, curve: LevelCurve, slot?: XpCurve) => number;
+
+export declare type XpCurve = (context: XpCurveContext) => number;
+
+export declare interface XpCurveContext {
+    readonly xp: string;
+    readonly curve: LevelCurve;
+}
+
+export { }

package/dist/curve.js

@@ -0,0 +1,38 @@
+import { progressionError as e } from "./errors.js";
+import { integer as t, list as n, object as r, progressValue as i } from "./capture.js";
+//#region src/curve.ts
+var a = (t) => {
+	let r = n(t, 1e4).map((e) => i(e));
+	if (r.length === 0 || r[0] !== 0n || r.some((e, t) => t > 0 && e <= r[t - 1])) throw e("invalid_curve");
+	return Object.freeze({ thresholds: Object.freeze(r.map(String)) });
+}, o = (n) => {
+	let o = r(n, [
+		"base",
+		"growth",
+		"maxLevel"
+	]), s = t(o.maxLevel, 1, 1e4), c = o.growth;
+	if (typeof c != "number" || !Number.isFinite(c) || c < 1 || c > 100 || !/^[0-9]+(?:\.[0-9]{1,12})?$/.test(String(c))) throw e("invalid_curve");
+	let l = i(o.base);
+	if (l === 0n) throw e("invalid_curve");
+	let [u, d = ""] = String(c).split("."), f = 10n ** BigInt(d.length), p = BigInt(u + d), m = ["0"], h = 0n;
+	for (let t = 1; t < s; t++) {
+		if (h += l, h > 9223372036854775807n) throw e("overflow");
+		m.push(String(h)), l = (l * p + f - 1n) / f;
+	}
+	return a(m);
+}, s = ({ xp: e, curve: t }) => {
+	let n = i(e), r = 0, a = t.thresholds.length;
+	for (; r + 1 < a;) {
+		let e = Math.floor((r + a) / 2);
+		BigInt(t.thresholds[e]) <= n ? r = e : a = e;
+	}
+	return r + 1;
+}, c = (e, n, r = s) => {
+	let o = a(n.thresholds), c = Object.freeze({
+		xp: String(i(e)),
+		curve: o
+	});
+	return t(r(c), 1, o.thresholds.length);
+};
+//#endregion
+export { s as defaultXpCurve, a as explicitLevelCurve, o as levelCurve, c as resolveXpCurve };

package/dist/daily.d.ts

@@ -0,0 +1,152 @@
+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 const captureDailyProfile: (input: unknown) => DailyProfile;
+
+export declare const captureDailyState: (input: unknown, calendar: LoginCalendar) => DailyState;
+
+export declare interface DailyClaimInput {
+    readonly calendarId: string;
+    readonly requestId: string;
+}
+
+export declare interface DailyClaimPlan {
+    readonly dayIndex: number;
+    readonly streak: number;
+    readonly protectionRemaining: number;
+    readonly cycle: number;
+}
+
+export declare type DailyClaimPolicy = (input: DailyClaimPolicyContext) => DailyClaimPlan;
+
+export declare interface DailyClaimPolicyContext {
+    readonly calendar: LoginCalendar;
+    readonly previous: DailyState | null;
+    readonly window: DailyWindow;
+    readonly at: number;
+}
+
+export declare interface DailyProfile {
+    readonly timezone: string;
+    readonly version: string;
+}
+
+export declare class DailyProfileSource extends DailyProfileSource_base {
+}
+
+declare const DailyProfileSource_base: Context.ServiceClass<DailyProfileSource, "@voltro/DailyProfileSource", DailyProfileSourceService>;
+
+export declare interface DailyProfileSourceService {
+    readonly read: (subject: Subject, scope: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+    }) => Effect.Effect<DailyProfile, ProgressionError>;
+}
+
+export declare interface DailyReceipt {
+    readonly operationId: string;
+    readonly claimId: string;
+    readonly calendarId: string;
+    readonly dayKey: string;
+    readonly after: DailyState;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+export declare interface DailyState extends DailyWindow {
+    readonly calendarId: string;
+    readonly version: number;
+    readonly dayIndex: number;
+    readonly streak: number;
+    readonly protectionRemaining: number;
+    readonly cycle: number;
+    readonly at: number;
+}
+
+export declare interface DailyWindow {
+    readonly dayKey: string;
+    readonly dayOrdinal: number;
+    readonly from: number;
+    readonly until: number;
+    readonly timezone: string;
+}
+
+export declare const defaultDailyClaimPolicy: DailyClaimPolicy;
+
+/** Effect Cron owns the timezone/DST boundary; day ordinals count civil dates, not 24-hour intervals. */
+export declare const defaultDailyWindow: (input: {
+    readonly timezone: string;
+    readonly at: number;
+}) => DailyWindow;
+
+export declare const defineLoginCalendar: (input: LoginCalendarDefinition) => LoginCalendar;
+
+export declare interface LoginCalendar {
+    readonly id: string;
+    readonly version: number;
+    readonly days: readonly (readonly ProgressionReward[])[];
+    readonly streakProtection: number;
+}
+
+export declare interface LoginCalendarDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly days: readonly (readonly ProgressionReward[])[];
+    readonly streakProtection?: number;
+}
+
+export declare class LoginCalendarPort extends LoginCalendarPort_base {
+}
+
+declare const LoginCalendarPort_base: Context.ServiceClass<LoginCalendarPort, "@voltro/LoginCalendarPort", LoginCalendarService>;
+
+export declare interface LoginCalendarService {
+    readonly claim: (subject: Subject, input: DailyClaimInput) => Effect.Effect<DailyReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerDaily[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+export declare interface PlayerDaily {
+    readonly calendarId: string;
+    readonly version: number;
+    readonly dayKey: string;
+    readonly timezone: string;
+    readonly from: number;
+    readonly until: number;
+    readonly observedAt: number;
+    readonly claimed: boolean;
+    readonly dayIndex: number;
+    readonly streak: number;
+    readonly protectionRemaining: number;
+    readonly reward: readonly ProgressionReward[];
+}
+
+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;
+};
+
+export declare const resolveDailyClaim: (input: DailyClaimPolicyContext, slot?: DailyClaimPolicy) => DailyState;
+
+export { }

package/dist/daily.js

@@ -0,0 +1,126 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, list as r, object as i } from "./capture.js";
+import { captureRewards as a } from "./reward.js";
+import { questTimezone as o } from "./quests.js";
+import { Context as s, Cron as c } from "effect";
+//#region src/daily.ts
+var l = (o) => {
+	let s = i(o, [
+		"id",
+		"version",
+		"days",
+		"streakProtection"
+	]), c = r(s.days, 366).map((e) => a(e, 64));
+	if (!c.length) throw e("invalid_input");
+	return Object.freeze({
+		id: t(s.id),
+		version: n(s.version ?? 1, 1, 1e6),
+		days: Object.freeze(c),
+		streakProtection: n(s.streakProtection ?? 0, 0, 30)
+	});
+}, u = (t) => {
+	let r = i(t, ["timezone", "at"]), a = o(r.timezone), s = n(r.at, 0, 864e13), l = c.parse("0 0 * * *", a);
+	if (l._tag === "Failure") throw e("invalid_input");
+	let u = Math.floor(s / 1e3) * 1e3, d = c.match(l.success, new Date(u)) ? u : c.prev(l.success, new Date(u)).getTime(), f = c.next(l.success, new Date(d)).getTime();
+	n(d, 0, s), n(f, s + 1, 864e13);
+	let p = new Intl.DateTimeFormat("en-US", {
+		timeZone: a,
+		calendar: "iso8601",
+		numberingSystem: "latn",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	}).formatToParts(new Date(s)), m = (e) => p.find((t) => t.type === e)?.value, h = Number(m("year")), g = Number(m("month")), _ = Number(m("day"));
+	n(h, 1970, 9999), n(g, 1, 12), n(_, 1, 31);
+	let v = `${String(h).padStart(4, "0")}-${String(g).padStart(2, "0")}-${String(_).padStart(2, "0")}`;
+	return Object.freeze({
+		dayKey: v,
+		dayOrdinal: Math.floor(Date.UTC(h, g - 1, _) / 864e5),
+		from: d,
+		until: f,
+		timezone: a
+	});
+}, d = ({ calendar: t, previous: n, window: r }) => {
+	if (!n) return {
+		dayIndex: 0,
+		streak: 1,
+		protectionRemaining: t.streakProtection,
+		cycle: 0
+	};
+	let i = r.dayOrdinal - n.dayOrdinal - 1;
+	if (i < 0) throw e("conflict");
+	if (i > n.protectionRemaining) return {
+		dayIndex: 0,
+		streak: 1,
+		protectionRemaining: t.streakProtection,
+		cycle: n.cycle + 1
+	};
+	let a = (n.dayIndex + 1) % t.days.length, o = n.cycle + +(a === 0);
+	return {
+		dayIndex: a,
+		streak: n.streak + 1,
+		protectionRemaining: a === 0 ? t.streakProtection : n.protectionRemaining - i,
+		cycle: o
+	};
+}, f = (t, r) => {
+	let a = i(t, [
+		"calendarId",
+		"version",
+		"dayKey",
+		"dayOrdinal",
+		"from",
+		"until",
+		"timezone",
+		"dayIndex",
+		"streak",
+		"protectionRemaining",
+		"cycle",
+		"at"
+	]), s = n(a.at, 0, 864e13), c = u({
+		at: s,
+		timezone: o(a.timezone)
+	});
+	if (a.calendarId !== r.id || a.version !== r.version || a.dayKey !== c.dayKey || a.dayOrdinal !== c.dayOrdinal || a.from !== c.from || a.until !== c.until) throw e("invalid_record");
+	return Object.freeze({
+		...c,
+		calendarId: r.id,
+		version: r.version,
+		dayIndex: n(a.dayIndex, 0, r.days.length - 1),
+		streak: n(a.streak, 1, 2147483647),
+		protectionRemaining: n(a.protectionRemaining, 0, r.streakProtection),
+		cycle: n(a.cycle, 0, 2147483647),
+		at: s
+	});
+}, p = (t, r = d) => {
+	let a = l(t.calendar), o = n(t.at, 0, 864e13), s = u({
+		timezone: t.window.timezone,
+		at: o
+	}), c = t.previous === null ? null : f(t.previous, a);
+	if (c && (c.timezone !== s.timezone || c.dayOrdinal >= s.dayOrdinal || c.until > s.from || c.at > o)) throw e("conflict");
+	let p = i(r(Object.freeze({
+		calendar: a,
+		previous: c,
+		window: s,
+		at: o
+	})), [
+		"dayIndex",
+		"streak",
+		"protectionRemaining",
+		"cycle"
+	]);
+	return f({
+		...s,
+		...p,
+		calendarId: a.id,
+		version: a.version,
+		at: o
+	}, a);
+}, m = class extends s.Service()("@voltro/DailyProfileSource") {}, h = class extends s.Service()("@voltro/LoginCalendarPort") {}, g = (e) => {
+	let n = i(e, ["timezone", "version"]);
+	return Object.freeze({
+		timezone: o(n.timezone),
+		version: t(n.version)
+	});
+};
+//#endregion
+export { m as DailyProfileSource, h as LoginCalendarPort, g as captureDailyProfile, f as captureDailyState, d as defaultDailyClaimPolicy, u as defaultDailyWindow, l as defineLoginCalendar, p as resolveDailyClaim };