@quybt93/pcgf 0.0.1

package/plugins/phaser-casual-game-factory/templates/ui/ui-sfx.ts

@@ -0,0 +1,131 @@
+import type * as Phaser from 'phaser';
+import { getSfxVolume } from './audio-settings';
+
+const CLICK_URL = '/assets/sfx/ui_click.mp3';
+const CLOSE_URL = '/assets/sfx/ui_close.mp3';
+const CLICK_KEY = 'ui_click';
+const CLOSE_KEY = 'ui_close';
+
+/** One unlocked element per SFX; clones play overlapping presses. */
+const htmlPlayers: { click?: HTMLAudioElement; close?: HTMLAudioElement } = {};
+
+function ensureHtmlPlayer(kind: 'click' | 'close'): HTMLAudioElement {
+  const existing = htmlPlayers[kind];
+  if (existing) return existing;
+  const audio = new Audio(kind === 'click' ? CLICK_URL : CLOSE_URL);
+  audio.preload = 'auto';
+  htmlPlayers[kind] = audio;
+  return audio;
+}
+
+/** Warm HTML players; also queue Phaser cache when a scene loader is available. */
+export function preloadUiAudio(scene?: Phaser.Scene): void {
+  ensureHtmlPlayer('click');
+  ensureHtmlPlayer('close');
+  try {
+    ensureHtmlPlayer('click').load();
+    ensureHtmlPlayer('close').load();
+  } catch {
+    /* ignore */
+  }
+  if (!scene?.load || !scene.cache?.audio) return;
+  if (!scene.cache.audio.exists(CLICK_KEY)) {
+    scene.load.audio(CLICK_KEY, CLICK_URL);
+  }
+  if (!scene.cache.audio.exists(CLOSE_KEY)) {
+    scene.load.audio(CLOSE_KEY, CLOSE_URL);
+  }
+}
+
+function playHtml(kind: 'click' | 'close', baseVolume: number): void {
+  const volume = Math.max(0, Math.min(1, baseVolume * getSfxVolume()));
+  if (volume <= 0.001) return;
+  try {
+    const base = ensureHtmlPlayer(kind);
+    const node = base.cloneNode(true) as HTMLAudioElement;
+    node.volume = volume;
+    const run = node.play();
+    if (run && typeof run.catch === 'function') {
+      void run.catch(() => {
+        /* autoplay until gesture — ignore */
+      });
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
+/** Shared click — HTMLAudio so DOM/Phaser never depend on Phaser loader cache. */
+export function playUiClick(_scene?: Phaser.Scene): void {
+  playHtml('click', 0.8);
+}
+
+/** Shared close — HTMLAudio primary. */
+export function playUiClose(_scene?: Phaser.Scene): void {
+  playHtml('close', 0.7);
+}
+
+function isCloseControl(el: HTMLElement): boolean {
+  if (el instanceof HTMLButtonElement || el.getAttribute('role') === 'button') {
+    return (
+      el.classList.contains('modal-close') ||
+      el.classList.contains('factory-close') ||
+      el.hasAttribute('data-close-popup') ||
+      el.getAttribute('aria-label') === 'Close'
+    );
+  }
+  return false;
+}
+
+function findUiControl(target: EventTarget | null): HTMLElement | null {
+  const el = target as HTMLElement | null;
+  if (!el?.closest) return null;
+  const button = el.closest('button, [role="button"]');
+  return button instanceof HTMLElement ? button : null;
+}
+
+/**
+ * Document-wide DOM SFX:
+ * - every `button` / `[role=button]` → click (or close if ×)
+ * - click on modal dim (target === backdrop) → close
+ */
+export function bindDomUiSfx(options?: { unlockSound?: () => void }): void {
+  document.addEventListener(
+    'pointerdown',
+    () => {
+      const click = ensureHtmlPlayer('click');
+      const close = ensureHtmlPlayer('close');
+      click.load();
+      close.load();
+      options?.unlockSound?.();
+    },
+    { once: true, capture: true },
+  );
+
+  document.addEventListener(
+    'click',
+    (event) => {
+      const target = event.target as HTMLElement | null;
+      if (!target) return;
+
+      if (target.classList?.contains('modal-backdrop') || target.classList?.contains('settings-backdrop')) {
+        playUiClose();
+        return;
+      }
+
+      const control = findUiControl(target);
+      if (!control) return;
+      if (control instanceof HTMLButtonElement && control.disabled) return;
+      if (control.getAttribute('aria-disabled') === 'true') return;
+      // Settings Home is an action button (click), not close.
+      if (control.id === 'settings-home') {
+        playUiClick();
+        return;
+      }
+
+      if (isCloseControl(control)) playUiClose();
+      else playUiClick();
+    },
+    true,
+  );
+}

package/plugins/phaser-casual-game-factory/templates/ui-reskin/compare.html

@@ -0,0 +1,235 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>PCGF UI Reskin — Compare</title>
+    <style>
+      :root {
+        --bg: #fff6ea;
+        --card: #ffffff;
+        --ink: #1f2937;
+        --muted: #6b7280;
+        --line: #e4dccf;
+        --ok: #22c55e;
+        --warn: #ffb703;
+        --hot: #ff4d6d;
+        --font: "Be Vietnam Pro", system-ui, sans-serif;
+      }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        font-family: var(--font);
+        color: var(--ink);
+        background: var(--bg);
+        min-height: 100vh;
+      }
+      header {
+        padding: 20px 24px 8px;
+        max-width: 1200px;
+        margin: 0 auto;
+      }
+      header h1 { margin: 0 0 6px; font-size: 1.4rem; }
+      header p { margin: 0; color: var(--muted); font-size: 0.95rem; }
+      .meta {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin: 16px auto 0;
+        max-width: 1200px;
+        padding: 0 24px;
+      }
+      .chip {
+        background: var(--card);
+        border: 1px solid var(--line);
+        box-shadow: 0 3px 0 var(--line);
+        border-radius: 999px;
+        padding: 6px 12px;
+        font-size: 0.85rem;
+      }
+      .chip strong { font-weight: 700; }
+      .grid {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        gap: 16px;
+        max-width: 1200px;
+        margin: 16px auto 24px;
+        padding: 0 24px 40px;
+      }
+      @media (max-width: 900px) {
+        .grid { grid-template-columns: 1fr; }
+      }
+      .panel {
+        background: var(--card);
+        border: 1px solid var(--line);
+        box-shadow: 0 5px 0 var(--line);
+        border-radius: 18px;
+        overflow: hidden;
+        display: flex;
+        flex-direction: column;
+        min-height: 420px;
+      }
+      .panel-head {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 12px 16px;
+        border-bottom: 1px solid var(--line);
+        background: #fffaf3;
+      }
+      .panel-head h2 { margin: 0; font-size: 1rem; }
+      .tag {
+        font-size: 0.75rem;
+        font-weight: 700;
+        letter-spacing: 0.04em;
+        text-transform: uppercase;
+        padding: 4px 8px;
+        border-radius: 8px;
+      }
+      .tag-before { background: #fee2e2; color: #991b1b; }
+      .tag-after { background: #dcfce7; color: #166534; }
+      .panel-body {
+        padding: 16px;
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+      }
+      .panel-body img,
+      .panel-body iframe {
+        width: 100%;
+        border: 0;
+        border-radius: 12px;
+        background: #f3eee4;
+        min-height: 280px;
+        object-fit: contain;
+      }
+      .notes {
+        color: var(--muted);
+        font-size: 0.9rem;
+        line-height: 1.4;
+        white-space: pre-wrap;
+      }
+      .actions {
+        max-width: 1200px;
+        margin: 0 auto 48px;
+        padding: 0 24px;
+        display: flex;
+        flex-wrap: wrap;
+        gap: 12px;
+      }
+      button {
+        font: inherit;
+        font-weight: 700;
+        border: 0;
+        border-radius: 14px;
+        padding: 12px 18px;
+        cursor: pointer;
+        box-shadow: 0 5px 0 var(--line);
+      }
+      button:active {
+        transform: translateY(3px);
+        box-shadow: none;
+      }
+      .btn-ok { background: var(--ok); color: #fff; }
+      .btn-warn { background: var(--warn); color: #1f2937; }
+      .btn-hot { background: var(--hot); color: #fff; }
+      .hint {
+        max-width: 1200px;
+        margin: -24px auto 40px;
+        padding: 0 24px;
+        color: var(--muted);
+        font-size: 0.85rem;
+      }
+      audio { width: 100%; margin-top: 4px; }
+    </style>
+  </head>
+  <body>
+    <header>
+      <h1>UI Reskin compare</h1>
+      <p>
+        Review <strong>Before</strong> vs <strong>After</strong>. Approve before replacing
+        production theme / assets / feeling / SFX.
+      </p>
+    </header>
+
+    <div class="meta">
+      <!-- Agent: fill chips from the reskin session -->
+      <span class="chip">Theme: <strong id="meta-theme">cream-casual</strong></span>
+      <span class="chip">Assets: <strong id="meta-assets">super-casual (use existing)</strong></span>
+      <span class="chip">Feeling: <strong id="meta-feeling">phaser-ui-motion</strong></span>
+      <span class="chip">SFX: <strong id="meta-sfx">phaser-ui-sfx</strong></span>
+    </div>
+
+    <div class="grid">
+      <section class="panel" aria-label="Before">
+        <div class="panel-head">
+          <h2>Before (current)</h2>
+          <span class="tag tag-before">Old</span>
+        </div>
+        <div class="panel-body">
+          <!-- Replace src with screenshot / sprite sheet / iframe of current UI -->
+          <img id="before-img" alt="Before UI" src="" data-placeholder="Set before image src" />
+          <div class="notes" id="before-notes">Describe current chrome gaps here.</div>
+          <div>
+            <div>Click SFX (old)</div>
+            <audio id="before-click" controls src=""></audio>
+          </div>
+          <div>
+            <div>Close SFX (old)</div>
+            <audio id="before-close" controls src=""></audio>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel" aria-label="After">
+        <div class="panel-head">
+          <h2>After (proposed)</h2>
+          <span class="tag tag-after">New</span>
+        </div>
+        <div class="panel-body">
+          <!-- Replace src with proposed pack / restyle output -->
+          <img id="after-img" alt="After UI" src="" data-placeholder="Set after image src" />
+          <div class="notes" id="after-notes">Describe proposed pack / theme / feeling / SFX here.</div>
+          <div>
+            <div>Click SFX (new)</div>
+            <audio id="after-click" controls src="/assets/sfx/ui_click.mp3"></audio>
+          </div>
+          <div>
+            <div>Close SFX (new)</div>
+            <audio id="after-close" controls src="/assets/sfx/ui_close.mp3"></audio>
+          </div>
+        </div>
+      </section>
+    </div>
+
+    <div class="actions">
+      <button type="button" class="btn-ok" id="btn-approve">Approve — replace production UI</button>
+      <button type="button" class="btn-warn" id="btn-revise">Need changes</button>
+      <button type="button" class="btn-hot" id="btn-reject">Reject — keep Before</button>
+    </div>
+    <p class="hint">
+      Buttons only record intent in <code>localStorage.pcgf.uiReskinCompare</code> for the agent.
+      Tell the agent your choice in chat as well. Do not treat this page as an automatic deploy.
+    </p>
+
+    <script>
+      const decisionKey = "pcgf.uiReskinCompare";
+      function setDecision(value) {
+        const payload = { decision: value, at: new Date().toISOString() };
+        localStorage.setItem(decisionKey, JSON.stringify(payload));
+        alert("Recorded: " + value + "\nTell the agent in chat to apply or revise.");
+      }
+      document.getElementById("btn-approve").onclick = () => setDecision("approve");
+      document.getElementById("btn-revise").onclick = () => setDecision("revise");
+      document.getElementById("btn-reject").onclick = () => setDecision("reject");
+
+      for (const img of document.querySelectorAll("img[data-placeholder]")) {
+        if (!img.getAttribute("src")) {
+          img.alt = img.getAttribute("data-placeholder") || "Missing image";
+          img.style.minHeight = "280px";
+        }
+      }
+    </script>
+  </body>
+</html>

package/plugins/phaser-casual-game-factory/tests/README.md

@@ -0,0 +1,29 @@
+# Economy tests
+
+Run the tests from the plugin root:
+
+```powershell
+.\scripts\test-economy.ps1
+```
+
+The tests cover duplicate transactions, concurrent requests, atomic failure, item rolls, item apply/revert, and stale proposal protection.
+
+They also cover grant modes, reroll charging semantics, persistence reload, battle pass XP, and leveling reset.
+
+Leveling tests also validate config completeness and the shared UI view models. A finite experience track must define an XP curve for every level before its max level.
+
+Run the complete Economy + Leveling suite:
+
+```powershell
+.\scripts\test-all.ps1
+```
+
+Run only the Phaser browser smoke suite:
+
+```powershell
+.\scripts\test-browser.ps1
+```
+
+It covers LoadingView MVVM timing/queue behavior, real Home↔Game controls, hybrid
+HTML destination reveal bounds, Phaser scene lifecycle, the full Economy + Item +
+Leveling sample flow, localStorage reload, mobile layout, and page errors.

package/plugins/phaser-casual-game-factory/tests/condition.test.ts

@@ -0,0 +1,92 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DefaultConditionService, type ConditionConfig, type ConditionMetricProvider } from '../templates/condition';
+import { DefaultDailyLoginService } from '../templates/daily-login';
+import { DefaultEconomyService, LocalEconomyRepository, createDefaultEconomyRegistry } from '../templates/economy';
+import { DefaultLevelingService } from '../templates/leveling';
+import { MemoryStorageAdapter } from '../templates/phaser/browser-storage-adapter';
+import { DefaultTimeService, type TimeSource } from '../templates/time';
+import { demoConfig } from '../examples/economy-demo-config';
+import { levelingDemoConfig } from '../examples/leveling-demo-config';
+
+class MutableTimeSource implements TimeSource {
+  readonly kind = 'local' as const;
+  constructor(private value: number) {}
+  now(): number { return this.value; }
+  set(value: number): void { this.value = value; }
+}
+
+const at = (value: string): number => Date.parse(value);
+const ok = <T>(result: { ok: true; value: T } | { ok: false; error: Error }): T => {
+  if (!result.ok) throw result.error;
+  return result.value;
+};
+
+const config: ConditionConfig = {
+  definitions: {
+    playerLevel3: {
+      id: 'playerLevel3', title: 'Unlock Hero',
+      root: { type: 'metric', metric: 'level', params: { trackId: 'character' }, operator: '>=', target: 3, label: 'Player level', description: 'Reach Player Lv {target}' },
+    },
+    twoLoginDays: {
+      id: 'twoLoginDays',
+      root: { type: 'metric', metric: 'login-days', operator: '>=', target: 2, description: 'Login {current}/{target} days', progressFormat: 'fraction' },
+    },
+    featureGate: {
+      id: 'featureGate',
+      root: { type: 'all', conditions: [
+        { type: 'metric', metric: 'level', params: { trackId: 'character' }, operator: '>=', target: 3, label: 'Player level' },
+        { type: 'metric', metric: 'login-streak', operator: '>=', target: 2, label: 'Login streak' },
+      ] },
+    },
+  },
+};
+
+test('ConditionService evaluates player level and exposes description, fraction, and percent progress', async () => {
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter());
+  const economy = new DefaultEconomyService(repository, demoConfig, createDefaultEconomyRegistry());
+  const leveling = new DefaultLevelingService(repository, demoConfig, levelingDemoConfig);
+  ok(await leveling.addExp('character', 100, 'condition-xp-1'));
+  const conditions = new DefaultConditionService(repository, config);
+  const before = ok(await conditions.getViewModel('playerLevel3'));
+  assert.equal(before.met, false);
+  assert.equal(before.description, 'Reach Player Lv 3');
+  assert.equal(before.progress.label, '2/3 (67%)');
+  ok(await leveling.addExp('character', 150, 'condition-xp-2'));
+  const after = ok(await conditions.evaluate('playerLevel3'));
+  assert.equal(after.met, true);
+  assert.equal(after.progress.percent, 100);
+  assert.equal(await economy.getBalance('coin'), 50);
+});
+
+test('ConditionService evaluates total login days, consecutive days, and group progress', async () => {
+  const source = new MutableTimeSource(at('2025-01-01T12:00:00.000Z'));
+  const time = new DefaultTimeService(source, { timeZone: 'UTC' });
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter());
+  const dailyLogin = new DefaultDailyLoginService(repository, time);
+  ok(await dailyLogin.registerLogin());
+  source.set(at('2025-01-02T12:00:00.000Z'));
+  ok(await dailyLogin.registerLogin());
+  const conditions = new DefaultConditionService(repository, config);
+  assert.equal(ok(await conditions.evaluate('twoLoginDays')).progress.label, '2/2');
+  const gate = ok(await conditions.evaluate('featureGate'));
+  assert.equal(gate.met, false);
+  assert.equal(gate.children?.[1].met, true);
+  assert.equal(gate.progress.label, '0/3 (0%)');
+});
+
+test('ConditionService accepts remote-style config replacement and custom metric providers', async () => {
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter());
+  const questProvider: ConditionMetricProvider = { metric: 'quest-count', getValue: () => 4 };
+  const conditions = new DefaultConditionService(repository, { definitions: {} }, [questProvider]);
+  conditions.replaceConfig({ definitions: {
+    remoteQuestGate: { id: 'remoteQuestGate', root: { type: 'metric', metric: 'quest-count', operator: '>', target: 3, description: 'Finish more than {target} quests', progressFormat: 'percent' } },
+  } });
+  const view = ok(await conditions.getViewModel('remoteQuestGate'));
+  assert.equal(view.met, true);
+  assert.equal(view.description, 'Finish more than 3 quests');
+  assert.equal(view.progress.label, '100%');
+  assert.throws(() => conditions.replaceConfig({ definitions: {
+    invalid: { id: 'different-id', root: { type: 'metric', metric: 'level', operator: '>=', target: 1 } },
+  } }), /must match key/);
+});

package/plugins/phaser-casual-game-factory/tests/daily-login-reward.test.ts

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DefaultDailyLoginRewardService, DefaultDailyLoginService, type DailyLoginRewardsConfig } from '../templates/daily-login';
+import { DefaultEconomyService, LocalEconomyRepository, createDefaultEconomyRegistry } from '../templates/economy';
+import { MemoryStorageAdapter } from '../templates/phaser/browser-storage-adapter';
+import { DefaultTimeService, type TimeSource } from '../templates/time';
+import { demoConfig } from '../examples/economy-demo-config';
+
+class MutableTimeSource implements TimeSource { readonly kind = 'local' as const; constructor(private value: number) {} now() { return this.value; } set(value: number) { this.value = value; } }
+const at = (value: string) => Date.parse(value);
+const ok = <T>(result: { ok: true; value: T } | { ok: false; error: Error }): T => { if (!result.ok) throw result.error; return result.value; };
+const rewards: DailyLoginRewardsConfig = { programs: { normal: { id: 'normal', track: 'login-days', allowCatchUp: true, allowClaimAllUnclaimed: true, catchUpCost: [{ resourceId: 'gem', amount: 1 }], entries: [
+  { day: 1, rewards: [{ resourceId: 'coin', amount: 10 }] }, { day: 2, rewards: [{ resourceId: 'coin', amount: 20 }] }, { day: 3, rewards: [{ resourceId: 'coin', amount: 30 }] },
+] } } };
+
+test('daily reward claim is atomic, idempotent, and supports paid catch-up', async () => {
+  const source = new MutableTimeSource(at('2025-01-01T12:00:00.000Z'));
+  const time = new DefaultTimeService(source, { timeZone: 'UTC' });
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter());
+  const economy = new DefaultEconomyService(repository, demoConfig, createDefaultEconomyRegistry());
+  const login = new DefaultDailyLoginService(repository, time);
+  const service = new DefaultDailyLoginRewardService(repository, demoConfig, time, rewards);
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'daily-seed' }));
+  ok(await login.registerLogin());
+  const first = ok(await service.claim('normal', 'daily-claim-1'));
+  assert.equal(first.rewardDay, 1);
+  assert.equal(await economy.getBalance('coin'), 110);
+  assert.equal((await service.claim('normal', 'daily-claim-1')).ok, true);
+  assert.equal(await economy.getBalance('coin'), 110);
+  source.set(at('2025-01-02T12:00:00.000Z')); ok(await login.registerLogin());
+  source.set(at('2025-01-03T12:00:00.000Z')); ok(await login.registerLogin());
+  const catchUp = ok(await service.claim('normal', 'daily-claim-2', '2025-01-02'));
+  assert.equal(catchUp.rewardDay, 2);
+  assert.equal(await economy.getBalance('gem'), 9);
+  assert.equal(await economy.getBalance('coin'), 130);
+});
+
+test('VIP-style claim-all grants every unclaimed logged day atomically when enabled', async () => {
+  const source = new MutableTimeSource(at('2025-02-01T12:00:00.000Z')); const time = new DefaultTimeService(source, { timeZone: 'UTC' });
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter()); const login = new DefaultDailyLoginService(repository, time);
+  ok(await login.registerLogin()); source.set(at('2025-02-02T12:00:00.000Z')); ok(await login.registerLogin());
+  const service = new DefaultDailyLoginRewardService(repository, demoConfig, time, rewards);
+  const batch = ok(await service.claimAllUnclaimed('normal', 'vip-batch-1'));
+  assert.equal(batch.claims.length, 2); assert.equal((await repository.getSnapshot()).balances.coin, 30);
+});

package/plugins/phaser-casual-game-factory/tests/daily-login.test.ts

@@ -0,0 +1,73 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { LocalEconomyRepository } from '../templates/economy';
+import { MemoryStorageAdapter } from '../templates/phaser/browser-storage-adapter';
+import { DefaultTimeService, type TimeSource } from '../templates/time';
+import { DefaultDailyLoginService } from '../templates/daily-login';
+
+class MutableTimeSource implements TimeSource {
+  readonly kind = 'local' as const;
+  constructor(private value: number) {}
+  now(): number { return this.value; }
+  set(value: number): void { this.value = value; }
+}
+
+const at = (value: string): number => Date.parse(value);
+const ok = <T>(result: { ok: true; value: T } | { ok: false; error: Error }): T => {
+  if (!result.ok) throw result.error;
+  return result.value;
+};
+
+function createService(start = '2025-01-01T12:00:00.000Z') {
+  const source = new MutableTimeSource(at(start));
+  const time = new DefaultTimeService(source, { timeZone: 'UTC' });
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter());
+  const dailyLogin = new DefaultDailyLoginService(repository, time);
+  return { source, time, dailyLogin };
+}
+
+test('DailyLogin registers days once, exposes day lookup, and calculates current/longest streak', async () => {
+  const { source, dailyLogin } = createService();
+  assert.equal(ok(await dailyLogin.registerLogin()).registered, true);
+  assert.equal(ok(await dailyLogin.registerLogin()).registered, false);
+  source.set(at('2025-01-02T12:00:00.000Z'));
+  ok(await dailyLogin.registerLogin());
+  source.set(at('2025-01-04T12:00:00.000Z'));
+  ok(await dailyLogin.registerLogin());
+
+  assert.equal(await dailyLogin.hasLoggedIn('2025-01-02'), true);
+  assert.equal(await dailyLogin.hasLoggedIn('2025-01-03'), false);
+  assert.equal(await dailyLogin.getConsecutiveLoginDays(), 1);
+  const state = await dailyLogin.getState();
+  assert.equal(state.lastLoginDay, '2025-01-04');
+  assert.equal(state.currentStreak, 1);
+  assert.equal(state.longestStreak, 2);
+});
+
+test('DailyLogin accepts a portal source and blocks future or invalid dates', async () => {
+  const { dailyLogin } = createService('2025-02-10T12:00:00.000Z');
+  const portal = ok(await dailyLogin.registerLogin({ dayKey: '2025-02-09', source: 'portal', transactionId: 'portal-9' }));
+  assert.equal(portal.source, 'portal');
+  assert.equal(await dailyLogin.hasLoggedIn('2025-02-09'), true);
+  const future = await dailyLogin.registerLogin({ dayKey: '2025-02-11' });
+  const invalid = await dailyLogin.registerLogin({ dayKey: '2025-02-30' });
+  assert.equal(future.ok, false);
+  assert.equal(invalid.ok, false);
+});
+
+test('DailyLogin auto-registers at game entry and after TimeService crosses into a new day', async () => {
+  const { source, time, dailyLogin } = createService();
+  time.tick();
+  ok(await dailyLogin.startAutoRegistration());
+  source.set(at('2025-01-02T00:00:01.000Z'));
+  time.tick();
+  await new Promise<void>((resolve) => setImmediate(resolve));
+  assert.equal(await dailyLogin.hasLoggedIn('2025-01-01'), true);
+  assert.equal(await dailyLogin.hasLoggedIn('2025-01-02'), true);
+  assert.equal(await dailyLogin.getConsecutiveLoginDays(), 2);
+  dailyLogin.stopAutoRegistration();
+  source.set(at('2025-01-03T00:00:01.000Z'));
+  time.tick();
+  await new Promise<void>((resolve) => setImmediate(resolve));
+  assert.equal(await dailyLogin.hasLoggedIn('2025-01-03'), false);
+});