@underpostnet/cyberia 3.3.73 → 3.3.77

package/test/unit/cyberia/instance-data.test.js

@@ -0,0 +1,314 @@
+import { describe, it, expect } from 'vitest';
+import {
+  buildCyberiaMmoInstanceEnv,
+  getInstanceModels,
+  parseRgba,
+  toEntityMsg,
+  toMapMsg,
+  toInstanceMsg,
+  toObjectLayerMsg,
+  toActionMsg,
+  toQuestMsg,
+  toInstanceConfig,
+  buildFallbackConfig,
+  pingData,
+  objectLayerQueryFilter,
+  fetchObjectLayerBatch,
+  fetchObjectLayer,
+  fetchMapData,
+  fetchObjectLayerManifest,
+  fetchFullInstance,
+  skillDocsToConfig,
+  entityTypeDefaultDocsToConfig,
+  mergeEntityDefaults,
+  itemTypesOf,
+} from '../../../src/projects/cyberia/instance-data.js';
+import {
+  CYBERIA_INSTANCE_CONF_DEFAULTS,
+  DEFAULT_DEAD_ITEM_ID,
+  ENTITY_TYPE_DEFAULTS,
+} from '../../../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
+import { DEFAULT_INSTANCE_CODE } from '../../../src/client/components/cyberia/SharedDefaultsCyberia.js';
+
+const lean = (value) => ({ lean: async () => value, populate: () => lean(value) });
+
+describe('instance env', () => {
+  it('derives the server and client variables from the variant runtime', () => {
+    const server = buildCyberiaMmoInstanceEnv({
+      instance: { runtime: 'cyberia-server', path: '/forest', instanceCode: 'FOREST' },
+      env: { PORT: '4001' },
+    });
+    expect(server).toEqual({ PORT: '4001', INSTANCE_CODE: 'FOREST', CYBERIA_BASE_PATH: '/forest' });
+
+    const client = buildCyberiaMmoInstanceEnv({ instance: { runtime: 'cyberia-client', path: '/' } });
+    expect(client).toEqual({
+      CYBERIA_INSTANCE_CODE: DEFAULT_INSTANCE_CODE,
+      CYBERIA_DEFAULT_INSTANCE: DEFAULT_INSTANCE_CODE,
+      CYBERIA_BASE_PATH: '/',
+    });
+  });
+
+  it('leaves a runtime it does not know alone', () => {
+    expect(buildCyberiaMmoInstanceEnv({ instance: { runtime: 'nodejs', path: '/x' }, env: { A: '1' } })).toEqual({
+      A: '1',
+    });
+    expect(buildCyberiaMmoInstanceEnv({})).toEqual({});
+  });
+
+  it('names the context when no database provider was loaded for it', () => {
+    expect(() => getInstanceModels({ host: 'nowhere.test', path: '/' })).toThrow('nowhere.test');
+  });
+});
+
+describe('wire converters', () => {
+  it('parses css colours into wire components and treats anything else as transparent', () => {
+    expect(parseRgba('rgba(10, 20, 30, 0.5)')).toEqual({ r: 10, g: 20, b: 30, a: 128 });
+    expect(parseRgba('rgb(1,2,3)')).toEqual({ r: 1, g: 2, b: 3, a: 255 });
+    expect(parseRgba('')).toEqual({ r: 0, g: 0, b: 0, a: 0 });
+    expect(parseRgba('#ff0000')).toEqual({ r: 0, g: 0, b: 0, a: 0 });
+  });
+
+  it('fills every entity, map and instance field an empty document leaves out', () => {
+    const entity = toEntityMsg({});
+    expect(entity).toMatchObject({ entityType: 'floor', level: 0, dimX: 1, dimY: 1, objectLayerItemIds: [] });
+    expect(toEntityMsg({ level: 3, color: 'rgb(9,8,7)' })).toMatchObject({ level: 3, colorR: 9, colorB: 7 });
+
+    const map = toMapMsg({ _id: 'm1', entities: [{ entityType: 'bot' }] });
+    expect(map).toMatchObject({ mongoId: 'm1', gridX: 16, cellWidth: 32 });
+    expect(map.entities[0].entityType).toBe('bot');
+
+    const instance = toInstanceMsg({ _id: 'i1', portals: [{ sourceMapCode: 'a' }] });
+    expect(instance).toMatchObject({ mongoId: 'i1', topologyMode: 'hybrid', mapCodes: [] });
+    expect(instance.portals[0]).toMatchObject({ sourceMapCode: 'a', portalMode: 'inter-portal', targetCellX: 0 });
+    expect(instance.playerSpawn).toEqual({ sourceMapCode: '', sourceCellX: 0, sourceCellY: 0, random: false });
+  });
+
+  it('carries an object layer with its ledger and render, defaulting the ledger to off-chain', () => {
+    const msg = toObjectLayerMsg({ _id: 'o1', data: { item: { id: 'hatchet', type: 'weapon', activable: 1 } } });
+    expect(msg).toMatchObject({
+      mongoId: 'o1',
+      item: { id: 'hatchet', type: 'weapon', description: '', activable: true },
+      ledger: { type: 'OFF_CHAIN', address: '', tokenId: '' },
+      render: { cid: '', metadataCid: '' },
+      sha256: '',
+      cid: '',
+    });
+    expect(toObjectLayerMsg({ _id: 'o2' }).item.id).toBe('');
+  });
+
+  it('carries vendor, craft and quest content with their defaults', () => {
+    const action = toActionMsg({
+      code: 'shop',
+      shopItems: [{ itemId: 'hatchet' }],
+      craftRecipes: [{ outputItems: [{ itemId: 'plank' }], ingredients: [{ itemId: 'wood-1', qty: 2 }] }],
+      questDialogueCodes: [{ questCode: 'q1' }],
+    });
+    expect(action.shopItems[0]).toEqual({ itemId: 'hatchet', priceItemId: 'coin', priceQty: 1 });
+    expect(action.craftRecipes[0]).toEqual({
+      outputItems: [{ itemId: 'plank', qty: 1 }],
+      ingredients: [{ itemId: 'wood-1', qty: 2 }],
+      craftTimeMs: 0,
+    });
+    expect(action.questDialogueCodes[0]).toEqual({ questCode: 'q1', dialogCode: '' });
+    expect(toActionMsg({})).toMatchObject({ code: '', storageSlots: 0, shopItems: [] });
+
+    const quest = toQuestMsg({
+      code: 'q1',
+      steps: [{ id: 's1', objectives: [{ type: 'collect', itemId: 'wood-1' }] }],
+      rewards: [{ itemId: 'coin' }],
+    });
+    expect(quest.steps[0].objectives[0]).toEqual({ type: 'collect', itemId: 'wood-1', quantity: 1 });
+    expect(quest.rewards[0]).toEqual({ itemId: 'coin', quantity: 1 });
+    expect(toQuestMsg({})).toMatchObject({ code: '', steps: [], unlocksQuestCodes: [] });
+  });
+});
+
+describe('instance config', () => {
+  it('is the canonical defaults for a world without a conf', () => {
+    expect(toInstanceConfig(null)).toEqual(buildFallbackConfig());
+    expect(buildFallbackConfig()).toEqual(CYBERIA_INSTANCE_CONF_DEFAULTS);
+    expect(buildFallbackConfig()).not.toBe(CYBERIA_INSTANCE_CONF_DEFAULTS);
+  });
+
+  it('keeps every field a conf sets and fills the rest from the defaults', () => {
+    const config = toInstanceConfig({
+      tickRate: 5,
+      economyRules: { portalFee: 9 },
+      skillRules: { projectileWidth: 3, doppelgangerSpawnChance: 0.2 },
+      equipmentRules: { requireSkin: false },
+      lifeRegenChance: 7,
+    });
+    const fb = CYBERIA_INSTANCE_CONF_DEFAULTS;
+    expect(config.tickRate).toBe(5);
+    expect(config.snapshotRate).toBe(fb.snapshotRate);
+    expect(config.economyRules).toEqual({ ...fb.economyRules, portalFee: 9 });
+    expect(config.skillRules).toEqual({ ...fb.skillRules, projectileWidth: 3, doppelgangerSpawnChance: 0.2 });
+    expect(config.equipmentRules).toEqual({ ...fb.equipmentRules, requireSkin: false });
+    expect(config.lifeRegenChance).toBe(fb.lifeRegenChance);
+    expect(config.skillConfig).toEqual([]);
+    expect(config.entityDefaults.map(({ entityType }) => entityType)).toEqual(
+      ENTITY_TYPE_DEFAULTS.map(({ entityType }) => entityType),
+    );
+  });
+
+  it('shapes skill and entity-type documents for the wire and drops the ones without a key', () => {
+    expect(skillDocsToConfig([{ triggerItemId: 'gun', skills: [{ logicEventId: 'projectile' }] }, {}, null])).toEqual([
+      {
+        triggerItemId: 'gun',
+        skills: [{ logicEventId: 'projectile', name: '', description: '', summonedEntityItemId: '' }],
+      },
+    ]);
+    expect(
+      entityTypeDefaultDocsToConfig([{ entityType: 'bot', liveItemIds: ['x'] }, { liveItemIds: ['y'] }]),
+    ).toMatchObject([{ entityType: 'bot', liveItemIds: ['x'], deadItemIds: [] }]);
+  });
+
+  it('completes a partial set of entity defaults with the canonical types it does not cover', () => {
+    const merged = mergeEntityDefaults([{ entityType: 'bot', liveItemIds: ['ghost'] }], { ghost: 'skin' });
+    const bots = merged.filter(({ entityType }) => entityType === 'bot');
+    expect(bots).toHaveLength(1);
+    expect(bots[0].liveItemIds).toEqual(['ghost']);
+    expect(merged.some(({ entityType }) => entityType === 'player')).toBe(true);
+    expect(itemTypesOf([{ data: { item: { id: 'ghost', type: 'skin' } } }, { data: {} }, null])).toEqual({
+      ghost: 'skin',
+    });
+  });
+});
+
+describe('transport-agnostic fetchers', () => {
+  const ol = (id, type = 'skin') => ({ _id: `ol-${id}`, sha256: `sha-${id}`, data: { item: { id, type } } });
+
+  it('answers a ping with the server clock', () => {
+    expect(pingData().serverTimeMs).toBeGreaterThan(0);
+  });
+
+  it('filters object layers by item type only when one is asked for', async () => {
+    expect(objectLayerQueryFilter('')).toEqual({});
+    expect(objectLayerQueryFilter('skin')).toEqual({ 'data.item.type': 'skin' });
+    const filters = [];
+    const models = { ObjectLayer: { find: (filter) => (filters.push(filter), lean([ol('anon')])) } };
+    const batch = await fetchObjectLayerBatch(models, 'skin');
+    expect(filters).toEqual([{ 'data.item.type': 'skin' }]);
+    expect(batch.map(({ item }) => item.id)).toEqual(['anon']);
+  });
+
+  it('resolves one object layer by item id, or null', async () => {
+    const models = { ObjectLayer: { findOne: ({ 'data.item.id': id }) => lean(id === 'anon' ? ol('anon') : null) } };
+    expect((await fetchObjectLayer(models, 'anon')).mongoId).toBe('ol-anon');
+    expect(await fetchObjectLayer(models, 'ghost')).toBeNull();
+  });
+
+  it('lists the id and digest of every object layer', async () => {
+    const models = { ObjectLayer: { find: () => lean([ol('anon'), { _id: 'x' }]) } };
+    expect(await fetchObjectLayerManifest(models)).toEqual({
+      entries: [
+        { itemId: 'anon', sha256: 'sha-anon' },
+        { itemId: '', sha256: '' },
+      ],
+    });
+  });
+
+  it('serves a map and records which instance serves it, surviving a registry failure', async () => {
+    const registry = [];
+    const models = {
+      CyberiaMap: { findOne: ({ code }) => lean(code === 'forest-1' ? { _id: 'm1', code } : null) },
+      GlobalMapCodeRegistry: {
+        findOneAndUpdate: (filter, update) => {
+          registry.push({ filter, update });
+          return Promise.reject(new Error('registry down'));
+        },
+      },
+    };
+    expect(await fetchMapData(models, { mapCode: 'ghost' })).toBeNull();
+    expect(await fetchMapData(models, { mapCode: 'forest-1' })).toMatchObject({ map: { code: 'forest-1' } });
+    expect(registry).toEqual([]);
+    const served = await fetchMapData(models, { mapCode: 'forest-1', instanceCode: 'FOREST' });
+    expect(served.map.mongoId).toBe('m1');
+    expect(registry).toEqual([
+      { filter: { mapCode: 'forest-1' }, update: { instanceCode: 'FOREST', status: 'active' } },
+    ]);
+    await new Promise((resolve) => setImmediate(resolve));
+  });
+});
+
+describe('full world load', () => {
+  const ol = (id, type = 'skin') => ({ _id: `ol-${id}`, sha256: `sha-${id}`, data: { item: { id, type } } });
+
+  it('serves the procedural world, with the canonical content, when the instance is unknown', async () => {
+    const queries = [];
+    const models = {
+      CyberiaInstance: { findOne: () => lean(null) },
+      ObjectLayer: { find: (filter) => (queries.push(filter), lean([ol('anon'), ol(DEFAULT_DEAD_ITEM_ID)])) },
+    };
+    const world = await fetchFullInstance(models, '');
+    expect(world.instance.seed).toBe('default');
+    expect(world.maps.length).toBeGreaterThan(0);
+    expect(world.maps[0].entities[0]).toHaveProperty('colorA');
+    expect(world.objectLayers.map(({ item }) => item.id)).toEqual(['anon', DEFAULT_DEAD_ITEM_ID]);
+    expect(world.config.skillConfig.map(({ triggerItemId }) => triggerItemId)).toContain('atlas_pistol_mk2');
+    expect(world.actions.length).toBeGreaterThan(0);
+    expect(world.quests.length).toBeGreaterThan(0);
+    expect(world.version).toMatch(/^fallback-[0-9a-f]{64}$/);
+    // Every canonical item is asked for, so anything a player can pick up resolves an atlas.
+    const wanted = queries[0]['data.item.id'].$in;
+    expect(wanted).toContain('anon');
+    expect(wanted).toContain(DEFAULT_DEAD_ITEM_ID);
+
+    const again = await fetchFullInstance(models, '');
+    expect(again.version).toBe(world.version);
+  });
+
+  it('loads a stored world from its conf, maps, content and the skills its items trigger', async () => {
+    const conf = { _id: 'c1', instanceCode: 'FOREST', tickRate: 7, entityTypeDefaults: [], updatedAt: 't1' };
+    const models = {
+      CyberiaInstance: {
+        findOne: () => lean({ _id: 'i1', code: 'FOREST', cyberiaMapCodes: ['forest-1'], conf, updatedAt: 't0' }),
+      },
+      CyberiaMap: {
+        find: () => lean([{ _id: 'm1', code: 'forest-1', entities: [{ objectLayerItemIds: ['atlas_pistol_mk2'] }] }]),
+      },
+      CyberiaEntityTypeDefault: { find: () => lean([]) },
+      CyberiaAction: {
+        find: () => lean([{ code: 'shop', sourceMapCode: 'forest-1', shopItems: [{ itemId: 'hatchet' }] }]),
+      },
+      CyberiaQuest: { find: () => lean([{ code: 'q1', sourceMapCode: 'forest-1' }]) },
+      CyberiaSkill: { find: () => lean([]) },
+      ObjectLayer: {
+        find: ({ 'data.item.id': { $in } }) =>
+          lean(
+            ['atlas_pistol_mk2', 'hatchet', 'atlas_pistol_mk2_bullet']
+              .filter((id) => $in.includes(id))
+              .map((id) => ol(id)),
+          ),
+      },
+    };
+    const world = await fetchFullInstance(models, 'FOREST');
+    expect(world.instance.code).toBe('FOREST');
+    expect(world.config.tickRate).toBe(7);
+    // The map places the pistol and the vendor sells the hatchet: both trigger skills this world runs.
+    const triggers = world.config.skillConfig.map(({ triggerItemId }) => triggerItemId);
+    expect(triggers).toContain('atlas_pistol_mk2');
+    expect(triggers).toContain('hatchet');
+    // What the skill summons needs an atlas too.
+    expect(world.objectLayers.map(({ item }) => item.id)).toContain('atlas_pistol_mk2_bullet');
+    expect(world.objectLayers.map(({ item }) => item.id)).toContain('hatchet');
+    expect(world.actions[0].shopItems[0].itemId).toBe('hatchet');
+    expect(world.quests[0].code).toBe('q1');
+    expect(world.version).toMatch(/^[0-9a-f]{64}$/);
+  });
+
+  it('runs a world whose conf reference is gone on the canonical defaults', async () => {
+    const models = {
+      CyberiaInstance: { findOne: () => lean({ _id: 'i1', code: 'BARE', cyberiaMapCodes: [], conf: null }) },
+      CyberiaInstanceConf: { findOne: () => lean(null) },
+      CyberiaEntityTypeDefault: { find: () => lean([]) },
+      ObjectLayer: { find: () => lean([]) },
+    };
+    const world = await fetchFullInstance(models, 'BARE');
+    expect(world.config.tickRate).toBe(CYBERIA_INSTANCE_CONF_DEFAULTS.tickRate);
+    expect(world.maps).toEqual([]);
+    expect(world.actions).toEqual([]);
+    expect(world.quests).toEqual([]);
+    expect(world.objectLayers).toEqual([]);
+  });
+});

package/test/unit/cyberia/instance-object-layer-items.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { fetchInstanceObjectLayerItemIds } from '../../../src/projects/cyberia/instance-data.js';
+
+const lean = (value) => ({ lean: async () => value, populate: () => lean(value) });
+
+const buildModels = ({ instance, maps = [], storedItemIds = [] }) => ({
+  CyberiaInstance: { findOne: () => lean(instance) },
+  CyberiaInstanceConf: { findOne: () => lean({ instanceCode: instance?.code, entityDefaults: [] }) },
+  CyberiaMap: { find: () => lean(maps) },
+  CyberiaEntityTypeDefault: { find: () => lean([]) },
+  CyberiaAction: { find: () => lean([]) },
+  CyberiaQuest: { find: () => lean([]) },
+  CyberiaSkill: { find: () => lean([]) },
+  ObjectLayer: {
+    find: (filter) => {
+      const wanted = new Set(filter['data.item.id'].$in);
+      return lean(storedItemIds.filter((id) => wanted.has(id)).map((id) => ({ _id: id, data: { item: { id } } })));
+    },
+  },
+});
+
+describe('instance object layer item ids', () => {
+  it('collects the item ids the instance maps place, limited to stored documents', async () => {
+    const models = buildModels({
+      instance: { _id: 'i1', code: 'FOREST', cyberiaMapCodes: ['forest-1'] },
+      maps: [
+        {
+          code: 'forest-1',
+          entities: [{ objectLayerItemIds: ['anon', 'hatchet'] }, { objectLayerItemIds: ['hatchet', '$runtime'] }],
+        },
+      ],
+      storedItemIds: ['anon', 'hatchet', 'unrelated'],
+    });
+    const itemIds = await fetchInstanceObjectLayerItemIds(models, 'FOREST');
+    expect(itemIds).toContain('anon');
+    expect(itemIds).toContain('hatchet');
+    expect(itemIds).not.toContain('unrelated');
+    expect(itemIds).not.toContain('$runtime');
+    expect(new Set(itemIds).size).toBe(itemIds.length);
+  });
+
+  it('fails on an unknown instance code instead of returning the fallback world', async () => {
+    const models = buildModels({ instance: null });
+    await expect(fetchInstanceObjectLayerItemIds(models, 'GHOST')).rejects.toThrow('"GHOST" not found');
+  });
+});

package/test/unit/cyberia/publish-workflow.test.js

@@ -0,0 +1,22 @@
+import { expect } from 'chai';
+import fs from 'fs-extra';
+// Named import: js-yaml's ESM build exports no default.
+import { load } from 'js-yaml';
+
+describe('the cyberia publish workflow', () => {
+  it('rewrites the published manifest after the install and before every publish', () => {
+    // The rewrite is the publish step's alone: a checkout that installed the published shape
+    // would run the engine source against a second engine in node_modules.
+    const workflow = load(fs.readFileSync('./.github/workflows/publish.cyberia.ci.yml', 'utf8'));
+
+    for (const [job, { steps }] of Object.entries(workflow.jobs)) {
+      const commands = steps.map(({ run }) => `${run ?? ''}`);
+      const restore = commands.findIndex((command) => command.includes('publishedProductPackageJson'));
+      const install = commands.findIndex((command) => command.trim().startsWith('npm ci'));
+      const publish = commands.findIndex((command) => command.includes('npm publish'));
+
+      expect(restore, `${job}: restores the published manifest`).to.be.greaterThan(install);
+      expect(restore, `${job}: restores it before publishing`).to.be.lessThan(publish);
+    }
+  });
+});

package/test/unit/cyberia/stat-balance.test.js

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { balanceStats, resolveStatBounds, statPolicyActive } from '../../../src/projects/cyberia/stat-balance.js';
+import {
+  STAT_TYPE_BOUNDS,
+  STAT_TYPES,
+  statBoundsForType,
+} from '../../../src/client/components/cyberia/SharedDefaultsCyberia.js';
+
+const wild = { effect: 60, resistance: -40, agility: 3, range: 25, intelligence: 9, utility: -2 };
+const lcg = (seed) => () => (seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0) / 4294967296;
+
+describe('stat balancing policy', () => {
+  it('is inert without normalize or random', () => {
+    expect(statPolicyActive({})).toBe(false);
+    expect(balanceStats({ stats: wild, itemType: 'weapon' })).toEqual(wild);
+  });
+
+  it('clamps into the semantic bounds of the item type', () => {
+    expect(balanceStats({ stats: wild, itemType: 'weapon', policy: { normalize: true } })).toEqual({
+      effect: 20,
+      resistance: -10,
+      agility: 3,
+      range: 10,
+      intelligence: 5,
+      utility: 0,
+    });
+    expect(balanceStats({ stats: wild, itemType: 'skin', policy: { normalize: true } })).toEqual({
+      effect: 1,
+      resistance: 0,
+      agility: 3,
+      range: 0,
+      intelligence: 2,
+      utility: 0,
+    });
+  });
+
+  it('keeps the contract bounds for a type without semantic bounds', () => {
+    expect(statBoundsForType('unknown')).toEqual(Object.fromEntries(STAT_TYPES.map((key) => [key, [-100, 100]])));
+    expect(balanceStats({ stats: wild, itemType: 'unknown', policy: { normalize: true } })).toEqual(wild);
+  });
+
+  it('is idempotent and deterministic', () => {
+    const once = balanceStats({ stats: wild, itemType: 'weapon', policy: { normalize: true } });
+    expect(balanceStats({ stats: once, itemType: 'weapon', policy: { normalize: true } })).toEqual(once);
+    const policy = { normalize: true, random: true, min: 0, max: 8 };
+    const first = balanceStats({ stats: wild, itemType: 'weapon', policy, random: lcg(7) });
+    expect(balanceStats({ stats: wild, itemType: 'weapon', policy, random: lcg(7) })).toEqual(first);
+    for (const key of STAT_TYPES) {
+      const [lo, hi] = resolveStatBounds('weapon', policy)[key];
+      expect(first[key]).toBeGreaterThanOrEqual(lo);
+      expect(first[key]).toBeLessThanOrEqual(hi);
+    }
+  });
+
+  it('lets min and max narrow the semantic range and pins a request outside it', () => {
+    expect(resolveStatBounds('weapon', { normalize: true, min: 12, max: 30 }).effect).toEqual([12, 20]);
+    expect(resolveStatBounds('weapon', { normalize: true, min: 50 }).effect).toEqual([20, 20]);
+    expect(resolveStatBounds('weapon', { normalize: true, max: -50 }).resistance).toEqual([-10, -10]);
+    expect(resolveStatBounds('weapon', { min: -20, max: 20 }).effect).toEqual([-20, 20]);
+    expect(() => resolveStatBounds('weapon', { min: 5, max: 1 })).toThrow('minimum');
+    expect(() => resolveStatBounds('weapon', { min: -101 })).toThrow();
+  });
+
+  it('declares every semantic bound inside the contract and in order', () => {
+    for (const bounds of Object.values(STAT_TYPE_BOUNDS)) {
+      for (const [lo, hi] of Object.values(bounds)) expect(lo <= hi && lo >= -100 && hi <= 100).toBe(true);
+    }
+  });
+});

package/test/unit/deploy-legacy-gateway-sweep.test.js

@@ -0,0 +1,63 @@
+'use strict';
+
+import { expect } from 'chai';
+import shell from 'shelljs';
+import { vi } from 'vitest';
+import UnderpostDeploy from '../../src/cli/deploy.js';
+
+describe('deploy legacy Gateway API sweep', () => {
+  let commands;
+  let listed;
+
+  beforeEach(() => {
+    commands = [];
+    listed = { Gateway: '', ClientTrafficPolicy: '' };
+    vi.spyOn(shell, 'exec').mockImplementation((command) => {
+      commands.push(command);
+      const kind = command.match(/^kubectl get (\w+) /)?.[1];
+      const stdout = kind ? listed[kind] : '';
+      return { code: 0, stdout, stderr: '', toString: () => stdout };
+    });
+  });
+
+  afterEach(() => vi.restoreAllMocks());
+
+  const deletes = () => commands.filter((command) => command.includes('kubectl delete'));
+
+  it('lists each kind once and deletes nothing on a namespace that was already migrated', () => {
+    // Regression: the sweep deleted `Gateway <host>`, `Gateway undefined` and both
+    // `-http3` policies blind, once per host — two dozen no-op round-trips per sync.
+    listed.Gateway = 'gateway.gateway.networking.k8s.io/dd-prototype-production\n';
+    listed.ClientTrafficPolicy = 'clienttrafficpolicy.gateway.envoyproxy.io/dd-prototype-production-http3\n';
+    const removed = UnderpostDeploy.API.sweepLegacyGatewayObjects({
+      hosts: ['healthcare.nexodev.org', 'www.bymyelectrics.com', 'bymyelectrics.com'],
+      namespace: 'default',
+    });
+    expect(removed).to.deep.equal({ gateways: [], policies: [] });
+    expect(commands.filter((command) => command.startsWith('kubectl get ')).length).to.equal(2);
+    expect(deletes()).to.deep.equal([]);
+  });
+
+  it('removes only the per-host and unresolved-host objects that still exist', () => {
+    listed.Gateway = [
+      'gateway.gateway.networking.k8s.io/dd-prototype-production',
+      'gateway.gateway.networking.k8s.io/healthcare.nexodev.org',
+      'gateway.gateway.networking.k8s.io/undefined',
+      'gateway.gateway.networking.k8s.io/other-deploy-production',
+    ].join('\n');
+    listed.ClientTrafficPolicy = 'clienttrafficpolicy.gateway.envoyproxy.io/undefined-http3\n';
+    const removed = UnderpostDeploy.API.sweepLegacyGatewayObjects({
+      hosts: ['healthcare.nexodev.org', 'www.bymyelectrics.com'],
+      namespace: 'default',
+    });
+    expect(removed).to.deep.equal({
+      gateways: ['healthcare.nexodev.org', 'undefined'],
+      policies: ['undefined-http3'],
+    });
+    expect(deletes()).to.deep.equal([
+      'sudo kubectl delete Gateway healthcare.nexodev.org -n default --ignore-not-found',
+      'sudo kubectl delete Gateway undefined -n default --ignore-not-found',
+      'sudo kubectl delete ClientTrafficPolicy undefined-http3 -n default --ignore-not-found',
+    ]);
+  });
+});

package/test/unit/deploy-log-table.test.js

@@ -85,7 +85,7 @@ const stream = [
 let workDir;
 let streamPath;
 
-const runQuiet = ({ tty = false, plain = false, ci = false, exitCode = 0 } = {}) => {
+const runQuiet = ({ tty = false, plain = false, ci = false, debug = false, exitCode = 0 } = {}) => {
   const command = `exit ${exitCode}`;
   const script = [
     'status=0',
@@ -106,6 +106,8 @@ const runQuiet = ({ tty = false, plain = false, ci = false, exitCode = 0 } = {})
   delete env.GITHUB_ACTIONS;
   delete env.RUN_QUIET_CI;
   if (ci) env.RUN_QUIET_CI = 'github';
+  delete env.RUN_QUIET_DEBUG;
+  if (debug) env.RUN_QUIET_DEBUG = '1';
 
   const [file, args] = tty ? ['script', ['-qec', `bash ${scriptPath}`, '/dev/null']] : ['bash', [scriptPath]];
   return execFileSync(file, args, { env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
@@ -128,7 +130,7 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
    * Runs the helper against an arbitrary stream and reports the exit status rather than
    * throwing, so a failing step is an assertion rather than a caught exception.
    */
-  const runWith = (lines, exitCode = 0) => {
+  const runWith = (lines, exitCode = 0, mode = { RUN_QUIET_PLAIN: '1' }) => {
     const logPath = path.join(failDir, 'stream.log');
     fs.writeFileSync(logPath, `${lines.join('\n')}\n`);
     const scriptPath = path.join(failDir, 'run.sh');
@@ -141,9 +143,12 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
         'echo REACHED_NEXT_STEP',
       ].join('\n'),
     );
-    const env = { ...process.env, RUN_QUIET_PLAIN: '1' };
+    const env = { ...process.env };
     delete env.GITHUB_ACTIONS;
     delete env.RUN_QUIET_CI;
+    delete env.RUN_QUIET_PLAIN;
+    delete env.RUN_QUIET_DEBUG;
+    Object.assign(env, mode);
     try {
       const stdout = execFileSync('bash', [scriptPath], { env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
       return { status: 0, stdout, stderr: '' };
@@ -158,6 +163,41 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
 
   afterEach(() => fs.removeSync(failDir));
 
+  // The failure report names two files and prints nothing out of them, so what the step captured
+  // is read back from the file rather than from the transcript.
+  const errorLog = (result) => {
+    const named = /error trace:\s+(\S+)/.exec(result.stderr);
+    expect(named, 'the failure report names an error trace').to.not.equal(null);
+    return fs.readFileSync(named[1], 'utf8');
+  };
+
+  it('latches a fatal runtime state in every rendering, including the debug stream', () => {
+    // The latch is parsed, not rendered. Turning the display off must not turn it off with it, or
+    // an audit run reports success on a deployment that never came up.
+    const podFatal = 'Target pod: dd-test-blue | Pod status: Running | Runtime status: error';
+
+    for (const [name, mode] of [
+      ['plain', { RUN_QUIET_PLAIN: '1' }],
+      ['ci', { RUN_QUIET_CI: 'github' }],
+      ['debug', { RUN_QUIET_DEBUG: '1' }],
+    ]) {
+      const result = runWith([podFatal], 0, mode);
+      expect(result.status, name).to.equal(1);
+      expect(result.stderr, name).to.include('reported a fatal runtime state but exited 0');
+      expect(result.stdout, name).to.not.include('REACHED_NEXT_STEP');
+    }
+  });
+
+  it('latches a fatal runtime state reported only by a monitor event, in the debug stream too', () => {
+    // The event arrives as a multi-line JSON block, so the state machine that reads it has to run
+    // in a mode that renders none of it.
+    const emitted = emit('08:11:33', 'runtime', 'runtime_error', 'error').split('\n');
+    const result = runWith(emitted, 0, { RUN_QUIET_DEBUG: '1' });
+
+    expect(result.status).to.equal(1);
+    expect(result.stdout, 'debug shows the event it latched on').to.include('"status": "error"');
+  });
+
   it('propagates a non-zero command status so `set -e` stops the deployment', () => {
     const result = runWith([podLine(POD_A, 'Running', 'running-deployment')], 7);
     expect(result.status).to.equal(7);
@@ -184,7 +224,10 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
     expect(result.status).to.equal(1);
     expect(result.stdout).to.not.include('REACHED_NEXT_STEP');
     expect(result.stderr).to.include('fatal runtime state but exited 0');
-    expect(result.stderr).to.include(POD_A);
+    // The pod name is captured output: a CI transcript is readable by anyone with the job log,
+    // so the latch detail belongs in the error log and nowhere else.
+    expect(result.stderr).to.not.include(POD_A);
+    expect(errorLog(result)).to.include(`pod ${POD_A}: runtime status=error`);
   });
 
   it('fails on a fatal runtime status carried by a monitor event rather than a pod row', () => {
@@ -196,7 +239,8 @@ describe('deploy failure propagation (run_quiet exit status)', () => {
       0,
     );
     expect(result.status).to.equal(1);
-    expect(result.stderr).to.include('runtime event: status=error');
+    expect(result.stderr).to.not.include('status=error');
+    expect(errorLog(result)).to.include('runtime event: status=error');
   });
 
   it('never hands off to the traffic switch on a pod reporting the fatal state', () => {
@@ -318,6 +362,33 @@ describe('deploy log table (run_quiet filter)', () => {
     expect(out).to.not.include(CHATTER_LINE);
   });
 
+  it('streams every line verbatim in debug mode, rendering nothing of its own', () => {
+    const out = runQuiet({ debug: true });
+
+    // What the other modes consume is exactly what an operator opened this session to read: the
+    // monitor's own JSON, and the report lines the table replaces.
+    expect(out).to.include('deploy-monitor');
+    expect(out).to.include('"phase": "kubernetes"');
+    expect(out).to.include('Target pod: ');
+    expect(out).to.include(READY_LINE);
+    expect(out).to.include(CHATTER_LINE);
+
+    // Nothing is rendered on top of the stream: no table, no CI section, no hand-off.
+    expect(out).to.not.include('POD NAME');
+    expect(out).to.not.include('refresh #');
+    expect(out).to.not.include('::group::');
+    expect(out).to.not.include('▶ Switch traffic');
+  });
+
+  it('keeps debug mode a passthrough even where a CI log would fold frames', () => {
+    // Debug is the operator asking for the stream, so it wins over the rendering the destination
+    // would otherwise get: a collapsed section hides exactly what the run is being watched for.
+    const out = runQuiet({ debug: true, ci: true });
+
+    expect(out).to.not.include('::group::');
+    expect(out).to.include('deploy-monitor');
+  });
+
   it('falls back to plain rows on a terminal when RUN_QUIET_PLAIN is set', function () {
     if (!hasScript) return this.skip();
     const out = runQuiet({ tty: true, plain: true });