@quybt93/pcgf 0.0.1

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

@@ -0,0 +1,258 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { demoConfig, inventoryDemoConfig } from '../examples/economy-demo-config';
+import { BrowserStorageAdapter, MemoryStorageAdapter, type StorageLike } from '../templates/phaser/browser-storage-adapter';
+import {
+  DefaultEconomyService,
+  DefaultItemService,
+  DefaultInventoryService,
+  LocalEconomyRepository,
+  createDefaultEconomyRegistry,
+  type RandomSource,
+  buildInventoryDetailViewModel,
+  buildItemRerollViewModel,
+} from '../templates/economy';
+
+class FixedRandom implements RandomSource {
+  constructor(private readonly value = 0) {}
+
+  next(): number {
+    return this.value;
+  }
+}
+
+class SharedStorage implements StorageLike {
+  private readonly values = new Map<string, string>();
+  getItem(key: string): string | null { return this.values.get(key) ?? null; }
+  setItem(key: string, value: string): void { this.values.set(key, value); }
+  removeItem(key: string): void { this.values.delete(key); }
+  clear(): void { this.values.clear(); }
+}
+
+function ok<T>(result: { ok: true; value: T } | { ok: false; error: Error }): T {
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+
+function createServices() {
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter());
+  const economy = new DefaultEconomyService(
+    repository,
+    demoConfig,
+    createDefaultEconomyRegistry(),
+    new FixedRandom(0),
+  );
+  const items = new DefaultItemService(
+    repository,
+    demoConfig,
+    new FixedRandom(0),
+    () => 1700000000000,
+  );
+  const inventory = new DefaultInventoryService(repository, demoConfig, inventoryDemoConfig, new FixedRandom(0));
+  return { repository, economy, items, inventory };
+}
+
+test('grant operation is idempotent for duplicate transaction IDs', async () => {
+  const { economy } = createServices();
+  ok(await economy.execute({
+    type: 'grant',
+    configId: 'starter',
+    transactionId: 'daily-player-1-day-1',
+  }));
+  ok(await economy.execute({
+    type: 'grant',
+    configId: 'starter',
+    transactionId: 'daily-player-1-day-1',
+  }));
+
+  assert.equal(await economy.getBalance('coin'), 100);
+  assert.equal(await economy.getBalance('gem'), 10);
+  assert.equal(await economy.getBalance('shard'), 50);
+});
+
+test('concurrent duplicate conversions commit only once', async () => {
+  const { economy } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'seed-1' }));
+
+  await Promise.all([
+    economy.execute({ type: 'convert', configId: 'gemToCoin', transactionId: 'convert-1' }),
+    economy.execute({ type: 'convert', configId: 'gemToCoin', transactionId: 'convert-1' }),
+  ]);
+
+  assert.equal(await economy.getBalance('gem'), 9);
+  assert.equal(await economy.getBalance('coin'), 200);
+});
+
+test('failed exchange is atomic and does not partially remove input', async () => {
+  const { economy } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'seed-2' }));
+
+  const result = await economy.execute({
+    type: 'sell',
+    configId: 'shardToCoin',
+    quantity: 6,
+    transactionId: 'sell-too-many-shards',
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(await economy.getBalance('shard'), 50);
+  assert.equal(await economy.getBalance('coin'), 100);
+});
+
+test('item creation stores rolled stats and skills', async () => {
+  const { items, repository } = createServices();
+  const item = ok(await items.createItem('sword-1', 'ironSword', 'create-item-1'));
+
+  assert.equal(item.stats.attack, 13);
+  assert.equal(item.skills['fire-strike'], 1);
+  assert.equal((await repository.getSnapshot()).items['sword-1'].revision, 1);
+});
+
+test('item reroll, apply, revert and duplicate apply are safe', async () => {
+  const { economy, items, repository } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'seed-3' }));
+  const original = ok(await items.createItem('sword-2', 'ironSword', 'create-item-2'));
+  const proposal = ok(await items.rollChange(
+    'sword-2',
+    'swordReroll',
+    'proposal-2',
+    'reroll-item-2',
+  ));
+
+  assert.notDeepEqual(proposal.before, proposal.after);
+  assert.equal(await economy.getBalance('gem'), 5);
+  ok(await items.applyChange('sword-2', 'proposal-2', 'apply-item-2'));
+  const afterApply = (await repository.getSnapshot()).items['sword-2'];
+  assert.equal(afterApply.stats.attack, 20);
+  assert.equal(await economy.getBalance('gem'), 5);
+
+  ok(await items.applyChange('sword-2', 'proposal-2', 'apply-item-2'));
+  assert.equal(await economy.getBalance('gem'), 5);
+
+  ok(await items.revertChange('sword-2', 'proposal-2', 'revert-item-2'));
+  const afterRevert = (await repository.getSnapshot()).items['sword-2'];
+  assert.deepEqual(afterRevert.stats, original.stats);
+  assert.deepEqual(afterRevert.skills, original.skills);
+  assert.equal(await economy.getBalance('coin'), 100);
+});
+
+test('failed item roll does not charge resources or create a proposal', async () => {
+  const { economy, items, repository } = createServices();
+  ok(await items.createItem('sword-4', 'ironSword', 'create-item-4'));
+
+  const result = await items.rollChange(
+    'sword-4',
+    'swordReroll',
+    'proposal-4',
+    'reroll-item-4',
+  );
+  assert.equal(result.ok, false);
+
+  const state = await repository.getSnapshot();
+  assert.equal(await economy.getBalance('gem'), 0);
+  assert.equal(state.itemProposals['proposal-4'], undefined);
+});
+
+test('stale item proposal cannot overwrite a newer revision', async () => {
+  const { economy, items } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'seed-4' }));
+  ok(await items.createItem('sword-3', 'ironSword', 'create-item-3'));
+  ok(await items.rollChange('sword-3', 'swordReroll', 'proposal-3', 'reroll-item-3'));
+  ok(await items.applyChange('sword-3', 'proposal-3', 'apply-item-3'));
+
+  const stale = await items.applyChange('sword-3', 'proposal-3', 'apply-item-3-second');
+  assert.equal(stale.ok, false);
+});
+
+test('grant all, weighted and selected modes produce configured rewards', async () => {
+  const { economy } = createServices();
+  const all = ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'grant-all' }));
+  assert.deepEqual(all.rewards?.filter((reward) => reward.type === 'resource'), [
+    { type: 'resource', resourceId: 'coin', amount: 100 },
+    { type: 'resource', resourceId: 'gem', amount: 10 },
+    { type: 'resource', resourceId: 'shard', amount: 50 },
+  ]);
+  const weighted = ok(await economy.execute({ type: 'grant', configId: 'chest', transactionId: 'grant-weighted' }));
+  assert.ok(weighted.rewards?.some((reward) => reward.type === 'resource'));
+  const selected = ok(await economy.execute({
+    type: 'grant', configId: 'selectable', selectedResourceIds: ['coin'], transactionId: 'grant-select',
+  }));
+  assert.ok(selected.rewards?.some((reward) => reward.type === 'resource' && reward.resourceId === 'coin'));
+});
+
+test('item reroll charges once and leaves the item unchanged until apply', async () => {
+  const { economy, items, repository } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'seed-reroll-only' }));
+  const original = ok(await items.createItem('sword-reroll-only', 'ironSword', 'create-reroll-only'));
+  const proposal = ok(await items.rollChange('sword-reroll-only', 'swordReroll', 'proposal-reroll-only', 'roll-reroll-only'));
+  assert.equal(await economy.getBalance('gem'), 5);
+  const unchanged = (await repository.getSnapshot()).items['sword-reroll-only'];
+  assert.deepEqual(unchanged.stats, original.stats);
+  assert.equal(proposal.status, 'pending');
+  assert.equal(await economy.getBalance('gem'), 5);
+});
+
+test('pending item proposal can be discarded without changing the item or refunding cost', async () => {
+  const { economy, items, repository } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'seed-discard-pending' }));
+  const original = ok(await items.createItem('sword-discard-pending', 'ironSword', 'create-discard-pending'));
+  const proposal = ok(await items.rollChange('sword-discard-pending', 'swordReroll', 'proposal-discard-pending', 'roll-discard-pending'));
+  ok(await items.revertChange('sword-discard-pending', proposal.proposalId, 'discard-pending'));
+  const state = await repository.getSnapshot();
+  assert.deepEqual(state.items['sword-discard-pending'].stats, original.stats);
+  assert.equal(await economy.getBalance('gem'), 5);
+});
+
+test('local persistence reload restores balances, items, levels and transaction idempotency', async () => {
+  const storage = new SharedStorage();
+  const firstRepository = new LocalEconomyRepository(new BrowserStorageAdapter(storage), 'reload-test');
+  const firstEconomy = new DefaultEconomyService(firstRepository, demoConfig, createDefaultEconomyRegistry());
+  const firstItems = new DefaultItemService(firstRepository, demoConfig, new FixedRandom(0), () => 1700000000000);
+  ok(await firstEconomy.execute({ type: 'grant', configId: 'starter', transactionId: 'reload-grant' }));
+  ok(await firstItems.createItem('reload-sword', 'ironSword', 'reload-item'));
+
+  const secondRepository = new LocalEconomyRepository(new BrowserStorageAdapter(storage), 'reload-test');
+  const secondEconomy = new DefaultEconomyService(secondRepository, demoConfig, createDefaultEconomyRegistry());
+  const secondItems = new DefaultItemService(secondRepository, demoConfig, new FixedRandom(0), () => 1700000000000);
+  assert.equal(await secondEconomy.getBalance('coin'), 100);
+  assert.equal((await secondRepository.getSnapshot()).items['reload-sword'].stats.attack, 13);
+  const duplicate = ok(await secondEconomy.execute({ type: 'grant', configId: 'starter', transactionId: 'reload-grant' }));
+  assert.equal(duplicate.applied, true);
+  assert.equal(await secondEconomy.getBalance('coin'), 100);
+  assert.equal((await secondRepository.getSnapshot()).items['reload-sword'].instanceId, 'reload-sword');
+});
+
+test('inventory supports all, weighted, select opening and selling with atomic receipts', async () => {
+  const { economy, inventory } = createServices();
+  ok(await inventory.grant('coinChest', 2, 'inventory-seed-chest'));
+  ok(await inventory.grant('mysteryBag', 1, 'inventory-seed-bag'));
+  ok(await inventory.grant('choiceTicket', 1, 'inventory-seed-ticket'));
+  const opened = ok(await inventory.open('coinChest', 2, 'inventory-open-all'));
+  const openedItemReward = opened.rewards?.find((reward) => reward.type === 'item' && reward.itemId === 'coinChest');
+  assert.equal(openedItemReward?.type === 'item' ? openedItemReward.amount : undefined, -2);
+  assert.equal(await economy.getBalance('coin'), 50);
+  ok(await inventory.open('mysteryBag', 1, 'inventory-open-weighted'));
+  ok(await inventory.open('choiceTicket', 1, 'inventory-open-select', ['gem']));
+  assert.equal(await economy.getBalance('gem'), 5);
+  ok(await inventory.grant('coinChest', 1, 'inventory-seed-sell'));
+  const sold = ok(await inventory.sell('coinChest', 1, 'inventory-sell'));
+  const soldCoinReward = sold.rewards?.find((reward) => reward.type === 'resource' && reward.resourceId === 'coin');
+  assert.equal(soldCoinReward?.type === 'resource' ? soldCoinReward.amount : undefined, 5);
+  assert.equal(await inventory.getAmount('coinChest'), 0);
+});
+
+test('economy UI view models expose reroll diff/cost and inventory amount bounds', async () => {
+  const { economy, items, inventory, repository } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'ui-seed' }));
+  const item = ok(await items.createItem('ui-sword', 'ironSword', 'ui-create'));
+  const proposal = ok(await items.rollChange('ui-sword', 'swordReroll', 'ui-proposal', 'ui-reroll'));
+  const state = await repository.getSnapshot();
+  const itemView = buildItemRerollViewModel(item, demoConfig.itemChanges.swordReroll.cost, state.balances, proposal);
+  assert.equal(itemView.costLabel, 'gem 5');
+  assert.equal(itemView.isPreviewing, true);
+  assert.ok(itemView.stats.some((stat) => stat.direction !== 'same'));
+  ok(await inventory.grant('coinChest', 3, 'ui-inventory-seed'));
+  const detail = buildInventoryDetailViewModel((await inventory.list()).find((entry) => entry.itemId === 'coinChest')!, 99);
+  assert.equal(detail.amount, 3);
+  assert.equal(detail.canOpen, true);
+});

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

@@ -0,0 +1,18 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DefaultEntitlementService } from '../templates/entitlement';
+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 Clock implements TimeSource { readonly kind = 'local' as const; now() { return 1000; } }
+test('EntitlementService activates packages, exposes features, and reconciles server ownership', async () => {
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter()); const time = new DefaultTimeService(new Clock());
+  const economy = new DefaultEconomyService(repository, demoConfig, createDefaultEconomyRegistry(), undefined, () => time.now());
+  const service = new DefaultEntitlementService(repository, economy, demoConfig.packages, time);
+  assert.equal(await service.isActive('vip'), false);
+  const activated = await service.activate('vip', 'vip-activate'); assert.equal(activated.ok, true);
+  assert.equal(await service.has('vip-daily-reward'), true);
+  const reconciled = await service.reconcile({ packageId: 'vip', permanent: true }, 'vip-server');
+  assert.equal(reconciled.ok, true); assert.equal(await service.get('vip').then((value) => value.permanent), true);
+});

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

@@ -0,0 +1,158 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { demoConfig } from '../examples/economy-demo-config';
+import { levelingDemoConfig } from '../examples/leveling-demo-config';
+import { MemoryStorageAdapter } from '../templates/phaser/browser-storage-adapter';
+import {
+  DefaultEconomyService,
+  LocalEconomyRepository,
+  createDefaultEconomyRegistry,
+} from '../templates/economy';
+import { DefaultLevelingService, buildLevelTrackViewModel, validateLevelingConfig } from '../templates/leveling';
+
+function ok<T>(result: { ok: true; value: T } | { ok: false; error: Error }): T {
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+
+function createServices() {
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter());
+  const economy = new DefaultEconomyService(repository, demoConfig, createDefaultEconomyRegistry());
+  const leveling = new DefaultLevelingService(repository, demoConfig, levelingDemoConfig);
+  return { repository, economy, leveling };
+}
+
+test('experience track levels up, preserves overflow, and aggregates rewards', async () => {
+  const { leveling, economy } = createServices();
+  const result = ok(await leveling.addExp('character', 280, 'character-xp-1'));
+
+  assert.equal(result.state.level, 3);
+  assert.equal(result.state.exp, 30);
+  assert.equal(result.state.totalExp, 280);
+  assert.equal(await economy.getBalance('coin'), 50);
+  assert.deepEqual(
+    result.receipt.rewards?.filter((reward) => reward.type === 'level-up'),
+    [
+      { type: 'level-up', trackId: 'character', level: 2 },
+      { type: 'level-up', trackId: 'character', level: 3 },
+    ],
+  );
+  assert.deepEqual(
+    result.receipt.rewards?.find((reward) => reward.type === 'feature-unlocked'),
+    { type: 'feature-unlocked', featureId: 'daily-quest' },
+  );
+});
+
+test('duplicate XP transaction does not grant rewards twice', async () => {
+  const { leveling, economy } = createServices();
+  ok(await leveling.addExp('character', 100, 'character-xp-duplicate'));
+  ok(await leveling.addExp('character', 100, 'character-xp-duplicate'));
+
+  assert.equal((await leveling.getState('character')).ok, true);
+  assert.equal(await economy.getBalance('coin'), 50);
+});
+
+test('resource level requires configured condition and cost', async () => {
+  const { leveling, economy } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'hero-seed-1a' }));
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'hero-seed-1b' }));
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'hero-seed-1c' }));
+
+  ok(await leveling.upgrade('hero', 'hero-upgrade-1'));
+  const blocked = await leveling.upgrade('hero', 'hero-upgrade-2-blocked');
+  assert.equal(blocked.ok, false);
+
+  ok(await leveling.addExp('character', 100, 'character-xp-for-hero'));
+  const upgraded = ok(await leveling.upgrade('hero', 'hero-upgrade-2'));
+  assert.equal(upgraded.state.level, 2);
+  assert.equal(await economy.getBalance('coin'), 50);
+  assert.equal(await economy.getBalance('shard'), 148);
+});
+
+test('resource level reset refunds configured percentage atomically', async () => {
+  const { leveling, economy } = createServices();
+  ok(await economy.execute({ type: 'grant', configId: 'starter', transactionId: 'hero-seed-2' }));
+  ok(await leveling.upgrade('hero', 'hero-upgrade-reset'));
+  assert.equal(await economy.getBalance('coin'), 0);
+
+  const reset = ok(await leveling.resetToDefault('hero', 'hero-reset-1'));
+  assert.equal(reset.state.level, 0);
+  assert.equal(await economy.getBalance('coin'), 50);
+});
+
+test('failed level reward does not persist XP or level', async () => {
+  const brokenEconomyConfig = {
+    ...demoConfig,
+    resources: {
+      ...demoConfig.resources,
+      coin: { ...demoConfig.resources.coin, maxBalance: 10 },
+    },
+  };
+  const repository = new LocalEconomyRepository(new MemoryStorageAdapter());
+  const leveling = new DefaultLevelingService(repository, brokenEconomyConfig, levelingDemoConfig);
+  const failed = await leveling.addExp('character', 100, 'character-reward-fails');
+
+  assert.equal(failed.ok, false);
+  const state = await repository.getSnapshot();
+  assert.equal(state.levels.character, undefined);
+  assert.equal(state.balances.coin, undefined);
+});
+
+test('battle pass shares the same experience contract and retains max-level overflow', async () => {
+  const { leveling } = createServices();
+  const result = ok(await leveling.addExp('battlePass', 1500, 'battle-pass-xp-1'));
+  assert.equal(result.state.level, 1);
+  assert.equal(result.state.exp, 500);
+  assert.equal(result.state.totalExp, 1500);
+});
+
+test('experience reset can clear progress and is idempotent', async () => {
+  const { leveling } = createServices();
+  ok(await leveling.addExp('character', 100, 'character-reset-xp'));
+  ok(await leveling.resetToDefault('character', 'character-reset-1'));
+  const state = ok(await leveling.getState('character'));
+  assert.equal(state.level, 1);
+  assert.equal(state.exp, 0);
+  assert.equal(state.totalExp, 0);
+  ok(await leveling.resetToDefault('character', 'character-reset-1'));
+  assert.deepEqual(ok(await leveling.getState('character')), state);
+});
+
+test('level upgrade preview exposes cost, conditions and max-level state', async () => {
+  const { leveling } = createServices();
+  const preview = ok(await leveling.getUpgradePreview('hero'));
+  assert.equal(preview.currentLevel, 0);
+  assert.equal(preview.nextLevel, 1);
+  assert.deepEqual(preview.costs, [{ resourceId: 'coin', amount: 100 }]);
+  ok(await leveling.getUpgradePreview('character'));
+});
+
+test('battle pass carries overflow from 2000/2200 into level 2', async () => {
+  const { leveling } = createServices();
+  ok(await leveling.addExp('battlePass', 3000, 'battle-pass-before-2000'));
+  let state = ok(await leveling.getState('battlePass'));
+  assert.equal(state.level, 1);
+  assert.equal(state.exp, 2000);
+  ok(await leveling.addExp('battlePass', 1000, 'battle-pass-cross-level-2'));
+  state = ok(await leveling.getState('battlePass'));
+  assert.equal(state.level, 2);
+  assert.equal(state.exp, 800);
+});
+
+test('leveling config validator catches missing XP curves before runtime', () => {
+  assert.throws(() => validateLevelingConfig({
+    tracks: {
+      broken: { id: 'broken', mode: 'experience', startLevel: 0, maxLevel: 3, xpToNext: { '0': 100 }, },
+    },
+  }), /missing positive xpToNext for level 1/);
+});
+
+test('level track view model exposes XP progress, max state, cost, and conditions', async () => {
+  const { leveling } = createServices();
+  const state = ok(await leveling.getState('hero'));
+  const preview = ok(await leveling.getUpgradePreview('hero'));
+  const viewModel = buildLevelTrackViewModel(levelingDemoConfig.tracks.hero, state, undefined, preview.conditions.length === 0);
+  assert.equal(viewModel.levelLabel, 'Lv 0 (Max 10)');
+  assert.equal(viewModel.costLabel, 'coin 100');
+  assert.equal(viewModel.conditionLabels.length, 0);
+});

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

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  calculateDisplayedProgress,
+  calculateWeightedProgress,
+  clampLoadingProgress,
+} from '../templates/loading-view/progress';
+
+test('loading progress is clamped to the valid range', () => {
+  assert.equal(clampLoadingProgress(-1), 0);
+  assert.equal(clampLoadingProgress(2), 1);
+  assert.equal(clampLoadingProgress(Number.NaN), 0);
+});
+
+test('displayed progress is the lower of real and minimum-time progress', () => {
+  assert.equal(calculateDisplayedProgress(0.8, 250, 1000), 0.25);
+  assert.equal(calculateDisplayedProgress(0.2, 750, 1000), 0.2);
+  assert.equal(calculateDisplayedProgress(1, 1000, 1000), 1);
+});
+
+test('zero minimum time follows real progress immediately', () => {
+  assert.equal(calculateDisplayedProgress(0.65, 0, 0), 0.65);
+  assert.equal(calculateDisplayedProgress(1, 0, 0), 1);
+});
+
+test('weighted progress aggregates scene and data tasks', () => {
+  assert.equal(
+    calculateWeightedProgress([
+      { progress: 0.5, weight: 2 },
+      { progress: 1, weight: 1 },
+    ]),
+    2 / 3,
+  );
+});
+
+test('zero-weight task sets finish only after the operation settles', () => {
+  assert.equal(calculateWeightedProgress([{ progress: 0, weight: 0 }], false), 0);
+  assert.equal(calculateWeightedProgress([{ progress: 0, weight: 0 }], true), 1);
+});

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

@@ -0,0 +1,60 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DefaultTimeService, ServerTimeSource, type TimeSource } from '../templates/time';
+
+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 utc = (value: string): number => Date.parse(value);
+
+test('TimeService emits minute, hour, day, week, and month boundaries in its configured timezone', () => {
+  const source = new MutableTimeSource(utc('2025-08-31T16:59:30.000Z')); // Sunday 23:59:30 in UTC+7
+  const time = new DefaultTimeService(source, { timeZone: 'Asia/Ho_Chi_Minh', weekStartsOn: 1 });
+  const fired: string[] = [];
+  time.on('new-minute', () => fired.push('minute'));
+  time.on('new-hour', () => fired.push('hour'));
+  time.on('new-day', () => fired.push('day'));
+  time.on('new-week', () => fired.push('week'));
+  time.on('new-month', () => fired.push('month'));
+  assert.equal(time.tick().dayKey, '2025-08-31');
+
+  source.set(utc('2025-08-31T17:00:05.000Z')); // Monday, 00:00:05 in UTC+7
+  const snapshot = time.tick();
+  assert.equal(snapshot.dayKey, '2025-09-01');
+  assert.equal(snapshot.weekKey, '2025-09-01');
+  assert.deepEqual(fired, ['minute', 'hour', 'day', 'week', 'month']);
+});
+
+test('TimeService supports independent custom minute intervals and unsubscribe', () => {
+  const source = new MutableTimeSource(utc('2025-01-01T00:04:30.000Z'));
+  const time = new DefaultTimeService(source, { timeZone: 'UTC' });
+  const ticks: number[] = [];
+  const unsubscribe = time.onEveryMinutes(5, ({ currentBucket }) => ticks.push(currentBucket));
+  time.tick();
+  source.set(utc('2025-01-01T00:05:01.000Z'));
+  time.tick();
+  unsubscribe();
+  source.set(utc('2025-01-01T00:10:01.000Z'));
+  time.tick();
+  assert.equal(ticks.length, 1);
+});
+
+test('week key honors a configurable first day of week', () => {
+  const source = new MutableTimeSource(utc('2025-01-05T12:00:00.000Z')); // Sunday
+  assert.equal(new DefaultTimeService(source, { timeZone: 'UTC', weekStartsOn: 1 }).snapshot().weekKey, '2024-12-30');
+  assert.equal(new DefaultTimeService(source, { timeZone: 'UTC', weekStartsOn: 0 }).snapshot().weekKey, '2025-01-05');
+});
+
+test('ServerTimeSource uses latest server offset while retaining the same TimeService API', async () => {
+  const local = new MutableTimeSource(1_000);
+  const server = new ServerTimeSource(async () => ({ unixMs: 5_000 }), local);
+  assert.equal(server.now(), 1_000);
+  await server.sync();
+  assert.equal(server.now(), 5_000);
+  local.set(2_000);
+  assert.equal(server.now(), 6_000);
+});