@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.28

package/dist/scripts/unified-tests.js

@@ -1,49 +1,89 @@
+/**
+ * TS 统一求解器断言(镜像 py test_unified 的航班链部分 + D-2 回归)。
+ * 运行(在 ts/ 下):npx tsx scripts/unified-tests.ts
+ */
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseFlightPackToSpec, solveUnified } from '../src/unified.js';
 import { hhmmToMin } from '../src/model.js';
 const pack = JSON.parse(await readFile(join('..', 'data', 'flights_2026.json'), 'utf-8'));
+// 1. 航班包经统一模型求解:可行、区间正确、负例排除、红眼精力
 const spec = parseFlightPackToSpec(pack);
 spec.budgetCny = 9000;
 const r1 = await solveUnified(spec);
 assert.equal(r1.feasible, true);
-assert.equal(r1.money_cny, r1.legs.reduce((a, l)=>a + l.price_cny, 0));
+// 工作窗口生效后 f2 被迫选 VZ303(¥350),有效组合区间下移(M-1 后重算)
+assert.equal(r1.money_cny, r1.legs.reduce((a, l) => a + l.price_cny, 0));
 assert.ok(7280 <= r1.money_cny && r1.money_cny <= 8350, `money=${r1.money_cny}`);
-const byLeg = Object.fromEntries(r1.legs.map((l)=>[
-        l.leg,
-        l
-    ]));
-assert.notEqual(byLeg['f4'].service, 'DZ6252');
+const byLeg = Object.fromEntries(r1.legs.map(l => [l.leg, l]));
+assert.notEqual(byLeg['f4'].service, 'DZ6252'); // 负例被锚点排除
 assert.equal(byLeg['f5'].service, 'EK329');
-assert.equal(byLeg['f5'].energy_pct, 79);
-assert.ok(byLeg['f5'].wake.includes('前一日'));
-assert.equal(byLeg['f5'].door_to_door, '11h20m');
+assert.equal(byLeg['f5'].energy_pct, 79); // 红眼睡眠模型(D-6 校准:机上 75 + 落地接驳 45min×5%/h≈+4 → 79;上限 80)
+assert.ok(byLeg['f5'].wake.includes('前一日')); // 跨日显示
+// D-5 时区感知核算(与 Python oracle 同款断言)
+assert.equal(byLeg['f5'].door_to_door, '11h20m'); // 3h 前置 + 7h35m 真实飞行 + 45m 接驳
 if (byLeg['f3'].service === 'MU6088') {
-    assert.equal(byLeg['f3'].door_to_door, '6h15m');
+    assert.equal(byLeg['f3'].door_to_door, '6h15m'); // +1h 时差已扣
 }
+// 2. D-2 回归:锚点冲突时 core 字符串不带竖线,精确点名
 const tight = parseFlightPackToSpec(pack);
 tight.segments[0].anchors.arriveByMin = hhmmToMin('15:00');
 const r2 = await solveUnified(tight);
 assert.equal(r2.feasible, false);
 assert.ok(r2.unsat_core.includes('f1:arrive_by'), `core=${JSON.stringify(r2.unsat_core)}`);
-assert.ok(r2.unsat_core.every((c)=>!c.includes('|')), 'core 无竖线残留');
-assert.ok(r2.suggestions.some((sg)=>sg.relax === 'f1:arrive_by'));
+assert.ok(r2.unsat_core.every(c => !c.includes('|')), 'core 无竖线残留');
+assert.ok(r2.suggestions.some(sg => sg.relax === 'f1:arrive_by'));
+// 3. 预算冲突 core 命名
 const poor = parseFlightPackToSpec(pack);
 poor.budgetCny = 1000;
 const r3 = await solveUnified(poor);
 assert.equal(r3.feasible, false);
 assert.ok(r3.unsat_core.includes('total:budget'));
+// 4. M-1:工作窗口排除周五晚班,gate q3 被确定性回答(与 Python oracle 同款)
 const excluded = r1.work_window_exclusions ?? [];
-assert.ok(excluded.some((e)=>e.segment === 'f2' && e.option === 'TG216'), JSON.stringify(excluded));
-assert.ok(excluded.some((e)=>e.segment === 'f2' && e.option === 'TG218'));
-assert.equal(byLeg['f2'].service, 'VZ303');
+assert.ok(excluded.some(e => e.segment === 'f2' && e.option === 'TG216'), JSON.stringify(excluded));
+assert.ok(excluded.some(e => e.segment === 'f2' && e.option === 'TG218'));
+assert.equal(byLeg['f2'].service, 'VZ303'); // 只剩周六早班——与真实选择一致
 const off = parseFlightPackToSpec(pack);
 off.budgetCny = 9000;
 off.workWindow = undefined;
 const r4 = await solveUnified(off);
-assert.deepEqual(r4.work_window_exclusions, []);
-console.log(`TS UNIFIED TESTS: 4/4 OK(工作窗口生效,f2=VZ303,¥${r1.money_cny})`);
-
-
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/unified-tests.ts
+assert.deepEqual(r4.work_window_exclusions, []); // 关掉窗口,周五班恢复可选
+// 5. Issue #620:yunnan-pack 的 yn0 段缺 buffer_min/origin_transfer_min/dest_transfer_min
+//    → 旧实现 Number(undefined)=NaN → Int.val(NaN) 在 z3 WASM 里 `Assertion failed`
+//    → 被兜底翻译成「不可行 + unsat_core:['wasm_runtime_error']」。三条红线:
+//    ① parse 边界必须点名拒收(不默认补 0);② 绕过 parse 的 NaN spec 必须以
+//    solver_error 返回而**绝不**是 infeasible;③ 补齐那三个字段后整包必须真能判定。
+const yunnanRaw = JSON.parse(await readFile(join('..', 'data', 'yunnan-pack.json'), 'utf-8'));
+// ① 真实数据包:yn0 的三个缺字段 → NaN → 必须是显式 solver_error,绝不是「不可行」
+const yunnanSpecRaw = parseFlightPackToSpec(structuredClone(yunnanRaw));
+yunnanSpecRaw.budgetCny = 9000;
+assert.ok(Number.isNaN(yunnanSpecRaw.segments[0].options[0].move.bufferMin), 'yn0 缺 buffer_min 的事实前提');
+const rYunnanRaw = await solveUnified(yunnanSpecRaw);
+assert.equal(rYunnanRaw.solver_error?.code, 'solver_input_not_integer', `yunnan 包必须以 solver_error 返回(got ${JSON.stringify(rYunnanRaw)})`);
+assert.ok(rYunnanRaw.solver_error.message.includes('yn0.bufferMin'), `solver_error 必须点名出问题的段与字段(got ${rYunnanRaw.solver_error.message})`);
+assert.equal(rYunnanRaw.feasible, false, 'solver_error 轮次没有产出可行解');
+assert.deepEqual(rYunnanRaw.unsat_core, undefined, '求解器失败不得伪造 unsat_core(机器 token 不进冲突位)');
+assert.ok(!JSON.stringify(rYunnanRaw).includes('wasm_runtime_error'), '不得再出现 wasm_runtime_error 这个伪冲突 token');
+// ② 最小输入:健康包里塞一个 NaN 接驳分钟 → 同样是 solver_error,点名到字段
+const nanSpec = parseFlightPackToSpec(pack);
+nanSpec.budgetCny = 9000;
+nanSpec.segments[0].options[0].move.bufferMin = Number.NaN;
+const rNan = await solveUnified(nanSpec);
+assert.equal(rNan.solver_error?.code, 'solver_input_not_integer', `NaN 接驳必须以 solver_error 返回(got ${JSON.stringify(rNan)})`);
+assert.ok(rNan.solver_error.message.includes('f1.bufferMin'), `solver_error 必须点名字段(got ${rNan.solver_error.message})`);
+assert.equal(rNan.feasible, false, 'solver_error 轮次没有产出可行解');
+// ③ 补齐 yn0 的三个字段(由测试提供,不改数据包:真值待 founder 校准)→ 整包真能判定,
+//    证明断言失败的最小输入正是这三个字段,其余四段编码本身没问题
+const yunnanFixed = structuredClone(yunnanRaw);
+Object.assign(yunnanFixed['legs'][0], {
+    buffer_min: 60, origin_transfer_min: 30, dest_transfer_min: 30,
+});
+const yunnanSpec = parseFlightPackToSpec(yunnanFixed);
+yunnanSpec.budgetCny = 9000;
+const rYunnan = await solveUnified(yunnanSpec);
+assert.equal(rYunnan.solver_error, undefined, `补齐三字段后不得再有求解器失败(got ${JSON.stringify(rYunnan.solver_error)})`);
+assert.equal(rYunnan.feasible, true, `yunnan 整包应可行(unsat_core=${JSON.stringify(rYunnan.unsat_core)})`);
+assert.equal(rYunnan.legs.length, 5, '五段全判定');
+console.log(`TS UNIFIED TESTS: 5/5 OK(工作窗口生效,f2=VZ303,¥${r1.money_cny};#620 yunnan NaN→solver_error 点名 yn0,补齐三字段后可行 ¥${rYunnan.money_cny})`);

package/dist/scripts/visa-policy-tests.js

@@ -0,0 +1,62 @@
+/**
+ * 政策事实生产端 v1 测试(issue #141,D-26 收口切片;冻结泰国页 fixture,零网络):
+ *
+ *  1. extractVisaSection:「签证入境」章节抽取(免签/落地签条款在案;缺章节=null)
+ *  2. splitPolicyEntries:中文序号段落切分(一、二、…),短段过滤
+ *  3. policyFactsFromMfa:PolicyFact 形态完整(schema/fact_id/as_of/review_by=D+30/来源证据链);幂等
+ *  4. VISA_POLICY_FETCH 效应行:策略表行在案(永不重试+断路器护站);注入 handler 走抓取编排
+ *  5. listCountryPaths:洲列表页国家路径提取(仅本站相对链接)
+ *
+ * 运行(在 ts/ 下):npx tsx scripts/visa-policy-tests.ts
+ */
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { splitPolicyEntries, continentListUrl, countryPageUrl, extractVisaSection, policyFactsFromMfa, } from '../capabilities/visa-policy.js';
+import { makeProductionInterpreter, __resetEffectBreakersForTest } from '../capabilities/effect.js';
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const FIXTURE = join(ROOT, 'data', 'fixtures', 'visa-policy-tg-sample.html');
+let passed = 0;
+function check(cond, msg) {
+    if (cond) {
+        passed++;
+        console.log(`  ok - ${msg}`);
+    }
+    else {
+        console.error(`  FAIL - ${msg}`);
+        process.exitCode = 1;
+    }
+}
+const html = readFileSync(FIXTURE, 'utf-8');
+// 1. 章节抽取
+const section = extractVisaSection(html);
+check(!!section && section.includes('免签'), '签证入境章节应被抽取(免签条款在案)');
+check(section.includes('2024'), '生效日期应保留(逐段溯源)');
+// 2. 条目切分
+const entries = splitPolicyEntries(section);
+check(entries.length >= 2, `中文序号段落切分(实际 ${entries.length} 条)`);
+check(entries.every(e => e.length > 30), '条目长度下限(短段过滤)');
+// 3. PolicyFact 形态
+const fetchedAt = '2026-09-05T00:00:00.000Z';
+const facts = policyFactsFromMfa({ countryLabel: '泰国', countryPath: 'tg_647570', section: section, fetchedAt });
+check(facts.length === entries.length, '事实数=条目数');
+check(facts.every(f => f.kind === 'policy' && f.schema === 'gotry_bookable_fact.v1'), 'PolicyFact 形态');
+check(facts.every(f => f.as_of === '2026-09-05' && f.review_by === '2026-10-05'), 'as_of 抓取日 + review_by=D+30');
+check(facts.every(f => f.source.startsWith('cs-mfa@') && f.query_id.startsWith('visa-policy:cs-mfa:')), '来源证据链 cs.mfa.gov.cn');
+// 幂等:同输入重跑 fact_id 稳定
+const facts2 = policyFactsFromMfa({ countryLabel: '泰国', countryPath: 'tg_647570', section: section, fetchedAt });
+check(facts.every((f, i) => f.fact_id === facts2[i].fact_id), 'fact_id 幂等');
+// 4. URL 形态受控
+assert.equal(countryPageUrl('yz_645708', 'tg_647570'), 'https://cs.mfa.gov.cn/zggmcg/ljmdd/yz_645708/tg_647570/', 'URL 形态');
+assert.equal(countryPageUrl('..', 'x'), null, '路径穿越拒绝');
+assert.equal(continentListUrl('..'), null, '洲路径穿越拒绝');
+// 5. 效应行:VISA_POLICY_FETCH 在注册表(永不重试+断路器护站)
+__resetEffectBreakersForTest();
+const interp = makeProductionInterpreter({ sleep: async () => { }, breakers: new Map(), handlers: {
+        VISA_POLICY_FETCH: async () => ({ ok: true, via: 'cs-mfa', evidence: 'e', latencyMs: 1, facts: [], countries: ['tg_647570'] }),
+    } });
+const out = await interp({ effect: 'VISA_POLICY_FETCH', params: { country: 'tg_647570' } });
+assert.equal(out.trace.channel, 'api', 'trace.channel=api(策略表行在案)');
+assert.equal(out.trace.attempts, 1, '礼貌抓取:单次执行(策略表 retry=null 生效)');
+console.log(`\nVISA POLICY TESTS: ${passed} pass${process.exitCode ? ', FAIL' : ' (全绿)'}`);

package/dist/scripts/weather-tests.js

@@ -1,48 +1,283 @@
+/**
+ * 天气能力层确定性回归：受控 fetch fixture 覆盖行为和时间预算。
+ *
+ * 真实 Open-Meteo/Nominatim 观测不参与合并闸；本套件必须离线、快速、可重复。
+ */
 import assert from 'node:assert/strict';
 import { geocodePlace, getForecast, getClimate, wmoLabel } from '../capabilities/weather.js';
-const geo = await geocodePlace('大理市', {
-    count: 10
+const jsonResponse = (body, status = 200) => new Response(JSON.stringify(body), {
+    status, headers: { 'content-type': 'application/json' },
 });
-assert.equal(geo.ok, true, `geocode ok: ${geo.error ?? ''}`);
-assert.ok(geo.results.length > 0, '应有结果');
-const dali = geo.results.find((r)=>(r.admin1 ?? '').includes('云南')) ?? geo.results[0];
-assert.ok(Math.abs(dali.latitude - 25.6) < 0.5, `纬度应≈25.6,实际 ${dali.latitude}(${dali.name},${dali.admin1})`);
-assert.match(geo.evidence, /open-meteo-geo@2/, '证据链带时间戳');
-console.log(`1. geocode 大理市 → ${dali.latitude},${dali.longitude} (${dali.name},${dali.admin1}) OK`);
-const fc = await getForecast({
-    latitude: dali.latitude,
-    longitude: dali.longitude
-}, {
-    days: 7
+const geoDali = { results: [{ name: '大理市', latitude: 25.6, longitude: 100.2, country: '中国', admin1: '云南省', population: 600000, feature_code: 'PPLA' }] };
+const geoPhuket = [{ name: 'Phuket', lat: '7.88', lon: '98.39', address: { country: '泰国', province: '普吉府' } }];
+const forecastBody = (days) => ({
+    timezone: 'Asia/Shanghai',
+    daily: {
+        time: Array.from({ length: days }, (_, i) => `2026-09-${String(i + 1).padStart(2, '0')}`),
+        temperature_2m_max: Array.from({ length: days }, () => 30),
+        temperature_2m_min: Array.from({ length: days }, () => 21),
+        precipitation_probability_max: Array.from({ length: days }, () => 60),
+        weathercode: Array.from({ length: days }, () => 61),
+    },
 });
-assert.equal(fc.ok, true, `forecast ok: ${fc.error ?? ''}`);
-assert.equal(fc.daily.length, 7, '7 天');
-assert.ok(fc.daily[0].tempMaxC > -50 && fc.daily[0].tempMaxC < 60, '温度合理范围');
-assert.match(fc.evidence, /\[实时API:open-meteo@2/, '证据链');
-assert.ok(fc.latencyMs < 5000, `延迟应 <5s,实际 ${fc.latencyMs}ms`);
-console.log(`2. forecast 大理 7 天:${fc.daily[0].tempMinC}–${fc.daily[0].tempMaxC}°C ${wmoLabel(fc.daily[0].weatherCode)} OK`);
-const cl = await getClimate({
-    latitude: dali.latitude,
-    longitude: dali.longitude
-}, 8);
-assert.equal(cl.ok, true, `climate ok: ${cl.error ?? ''}`);
-assert.ok(cl.daily.length >= 28, '8 月应有 ≥28 天');
-assert.match(cl.evidence, /open-meteo-climate@/, '气候证据链');
-console.log(`3. climate 大理去年 8 月:${cl.daily.length} 天 OK`);
-const bad = await getForecast({
-    latitude: 999,
-    longitude: 0
-}, {
-    timeoutMs: 10_000
+const climateBodyFor = (year, month) => {
+    const days = new Date(Date.UTC(year, month, 0)).getUTCDate();
+    const monthText = String(month).padStart(2, '0');
+    return { daily: { time: Array.from({ length: days }, (_, i) => `${year}-${monthText}-${String(i + 1).padStart(2, '0')}`), temperature_2m_max: Array(days).fill(29), temperature_2m_min: Array(days).fill(21), weathercode: Array(days).fill(2) } };
+};
+const climateBody = climateBodyFor(2025, 8);
+const mockFetch = (handler) => async (input, init) => jsonResponse(await handler(String(input), init?.signal ?? new AbortController().signal));
+// 1. 地理编码主源命中 + schema/别名正常路径
+const geo = await geocodePlace('大理市', { count: 10, fetchImpl: mockFetch(() => geoDali) });
+assert.equal(geo.ok, true);
+assert.equal(geo.via, 'open-meteo');
+assert.ok(Math.abs(geo.results[0].latitude - 25.6) < 0.5);
+assert.match(geo.evidence, /open-meteo-geo@2/);
+console.log('1. geocode 主源命中 + alias/schema OK');
+// 2. 零结果进入 Nominatim 兜底，并保持正确国家/坐标
+const seenRequests = [];
+const phuket = await geocodePlace('普吉岛', { count: 3, fetchImpl: async (input, init) => {
+        seenRequests.push({ url: String(input), headers: new Headers(init?.headers) });
+        return jsonResponse(String(input).includes('nominatim') ? geoPhuket : { results: [] });
+    } });
+assert.equal(phuket.ok, true);
+assert.equal(phuket.via, 'nominatim');
+assert.match(phuket.results[0].country ?? '', /泰国/);
+assert.ok(Math.abs(phuket.results[0].latitude - 8) < 0.5);
+assert.match(seenRequests[0].url, /name=%E6%99%AE%E5%90%89%E5%B2%9B.*count=3.*language=zh/);
+assert.match(seenRequests[1].url, /q=%E6%99%AE%E5%90%89%E5%B2%9B.*limit=3.*accept-language=zh/);
+assert.match(seenRequests[1].headers.get('user-agent') ?? '', /gotry-travel-agent/);
+const badAddress = await geocodePlace('坏地址', { fetchImpl: mockFetch((url) => url.includes('nominatim') ? [{ name: 'X', lat: '1', lon: '2', address: { country: {}, province: 7 } }] : { results: [] }) });
+assert.equal(badAddress.ok, true);
+assert.equal('country' in badAddress.results[0], false);
+assert.equal('admin1' in badAddress.results[0], false);
+console.log('2. geocode 兜底链 + 地名 alias OK');
+// 3. 预报正常 schema
+const fc = await getForecast({ latitude: 25.6, longitude: 100.2 }, { days: 7, fetchImpl: mockFetch(() => forecastBody(7)) });
+assert.equal(fc.ok, true);
+assert.equal(fc.daily?.length, 7);
+assert.equal(fc.daily?.[0]?.weatherCode, 61);
+assert.ok(fc.latencyMs < 1000);
+console.log('3. forecast schema/行为 OK');
+// 4. 慢 forecast 必须在受控 timeout 内 graceful fallback（不抛错）
+const slow = mockFetch((_url, signal) => new Promise((_, reject) => {
+    const abort = () => reject(new Error('This operation was aborted'));
+    if (signal.aborted)
+        abort();
+    else
+        signal.addEventListener('abort', abort, { once: true });
+    setTimeout(() => reject(new Error('late response')), 250);
+}));
+const slowStarted = Date.now();
+const slowFc = await getForecast({ latitude: 25.6, longitude: 100.2 }, { timeoutMs: 25, fetchImpl: slow });
+assert.equal(slowFc.ok, false);
+assert.ok(Date.now() - slowStarted < 150, 'slow forecast must respect timeout');
+assert.match(slowFc.evidence, /error/);
+const never = mockFetch(() => new Promise(() => undefined));
+const neverStarted = Date.now();
+const neverFc = await getForecast({ latitude: 25.6, longitude: 100.2 }, { timeoutMs: 20, fetchImpl: never });
+assert.equal(neverFc.ok, false);
+assert.ok(Date.now() - neverStarted < 150, 'hard deadline must cover a fetch that ignores abort');
+const neverBody = await getForecast({ latitude: 25.6, longitude: 100.2 }, { timeoutMs: 20, fetchImpl: async () => ({ ok: true, json: () => new Promise(() => undefined) }) });
+assert.equal(neverBody.ok, false, 'hard deadline must cover a body decoder that never settles');
+let lateResolve;
+const lateResolveResult = await getForecast({ latitude: 25.6, longitude: 100.2 }, {
+    timeoutMs: 10,
+    fetchImpl: async () => ({ ok: true, json: () => new Promise(resolve => { lateResolve = resolve; }) }),
 });
-assert.equal(bad.ok, false, '非法输入应返回 ok=false');
-assert.ok(bad.evidence.includes('error'), '降级证据标注');
-console.log(`4. 降级 ok=false 不抛错 OK`);
+assert.equal(lateResolveResult.ok, false);
+lateResolve?.(forecastBody(7));
+let lateReject;
+const lateRejectResult = await getForecast({ latitude: 25.6, longitude: 100.2 }, {
+    timeoutMs: 10,
+    fetchImpl: async () => ({ ok: true, json: () => new Promise((_, reject) => { lateReject = reject; }) }),
+});
+assert.equal(lateRejectResult.ok, false);
+lateReject?.(Object.create(null));
+await new Promise(resolve => setImmediate(resolve));
+console.log('4. slow forecast timeout + graceful fallback OK');
+// 5. 双源 fallback 的总预算：主源耗尽预算时不再发第二个请求。
+let calls = 0;
+const slowBoth = mockFetch((_url, signal) => {
+    calls += 1;
+    return new Promise((_, reject) => {
+        const abort = () => reject(new Error('network timeout'));
+        if (signal.aborted)
+            abort();
+        else
+            signal.addEventListener('abort', abort, { once: true });
+    });
+});
+const chainStarted = Date.now();
+const chain = await geocodePlace('不存在的地方', { timeoutMs: 35, fetchImpl: slowBoth });
+assert.equal(chain.ok, false);
+assert.equal(calls, 1, 'an exhausted primary budget must not start fallback');
+assert.ok(Date.now() - chainStarted < 150, 'fallback chain must share one total budget');
+assert.match(chain.evidence, /open-meteo-geo@error/);
+let fastPrimaryCalls = 0;
+let fastFallbackCalls = 0;
+const fallbackAfterFastFailure = await geocodePlace('不存在的地方', { timeoutMs: 100, fetchImpl: async (input, init) => {
+        if (String(input).includes('nominatim')) {
+            fastFallbackCalls += 1;
+            return jsonResponse([]);
+        }
+        fastPrimaryCalls += 1;
+        throw new Error('ECONNRESET');
+    } });
+assert.equal(fallbackAfterFastFailure.ok, false);
+assert.equal(fastPrimaryCalls, 1, 'primary should be attempted once');
+assert.equal(fastFallbackCalls, 1, 'a fast primary failure should still attempt fallback once');
+const network = await getForecast({ latitude: 25.6, longitude: 100.2 }, { fetchImpl: mockFetch(() => { throw new Error('ECONNRESET'); }) });
+assert.equal(network.ok, false);
+assert.match(network.error ?? '', /ECONNRESET/);
+const httpError = await getForecast({ latitude: 25.6, longitude: 100.2 }, { fetchImpl: async () => jsonResponse({}, 503) });
+assert.equal(httpError.ok, false);
+assert.match(httpError.error ?? '', /HTTP 503/);
+const malformedGeo = await geocodePlace('坏响应', { timeoutMs: 100, fetchImpl: mockFetch((url) => url.includes('nominatim') ? {} : { results: {} }) });
+assert.equal(malformedGeo.ok, false);
+console.log('5. slow geocode + strict fallback budget + network/HTTP errors OK');
+// 6. climate schema、malformed schema、WMO mapping
+const cl = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { year: 2025, fetchImpl: mockFetch(() => climateBody) });
+assert.equal(cl.ok, true);
+assert.equal(cl.daily?.length, 31);
+const malformed = await getForecast({ latitude: 25.6, longitude: 100.2 }, { days: 7, fetchImpl: mockFetch(() => ({ daily: { time: [] } })) });
+assert.equal(malformed.ok, false);
+const malformedElement = await getForecast({ latitude: 25.6, longitude: 100.2 }, { days: 7, fetchImpl: mockFetch(() => ({ daily: { ...forecastBody(7).daily, temperature_2m_max: [30, 'bad', 30, 30, 30, 30, 30] } })) });
+assert.equal(malformedElement.ok, false);
+const wrongPrecip = await getForecast({ latitude: 25.6, longitude: 100.2 }, { days: 7, fetchImpl: mockFetch(() => ({ daily: { ...forecastBody(7).daily, precipitation_probability_max: 'bad' } })) });
+assert.equal(wrongPrecip.ok, false);
+const wrongPrecipObject = await getForecast({ latitude: 25.6, longitude: 100.2 }, { days: 7, fetchImpl: mockFetch(() => ({ daily: { ...forecastBody(7).daily, precipitation_probability_max: {} } })) });
+assert.equal(wrongPrecipObject.ok, false);
+const absentPrecip = { daily: { ...forecastBody(7).daily } };
+delete absentPrecip.daily.precipitation_probability_max;
+const forecastAbsentPrecip = await getForecast({ latitude: 25.6, longitude: 100.2 }, { fetchImpl: mockFetch(() => absentPrecip) });
+assert.equal(forecastAbsentPrecip.ok, true);
+assert.equal(forecastAbsentPrecip.daily?.[0]?.precipProbMaxPct, null);
+const forecastNullPrecip = await getForecast({ latitude: 25.6, longitude: 100.2 }, { fetchImpl: mockFetch(() => ({ daily: { ...forecastBody(7).daily, precipitation_probability_max: null } })) });
+assert.equal(forecastNullPrecip.ok, true);
+assert.equal(forecastNullPrecip.daily?.[0]?.precipProbMaxPct, null);
+const forecastValidPrecip = await getForecast({ latitude: 25.6, longitude: 100.2 }, { fetchImpl: mockFetch(() => forecastBody(7)) });
+assert.equal(forecastValidPrecip.ok, true);
+assert.equal(forecastValidPrecip.daily?.[0]?.precipProbMaxPct, 60);
+const nullClimate = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { fetchImpl: mockFetch(() => null) });
+assert.equal(nullClimate.ok, false);
+const slowClimate = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { timeoutMs: 20, fetchImpl: slow });
+assert.equal(slowClimate.ok, false);
+const shortClimate = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { fetchImpl: mockFetch(() => ({ daily: { ...climateBody.daily, time: ['2025-08-01'], temperature_2m_max: [29], temperature_2m_min: [21], weathercode: [2] } })) });
+assert.equal(shortClimate.ok, false);
+for (const badDays of [0, Number.NaN, 2.5]) {
+    let fetches = 0;
+    const invalid = await getForecast({ latitude: 25.6, longitude: 100.2 }, { days: badDays, fetchImpl: mockFetch(() => { fetches += 1; return forecastBody(7); }) });
+    assert.equal(invalid.ok, false);
+    assert.equal(fetches, 0);
+}
+for (const badTimeout of [0, -1, Number.NaN, Number.POSITIVE_INFINITY, 2.5]) {
+    let forecastFetches = 0;
+    const invalidForecast = await getForecast({ latitude: 25.6, longitude: 100.2 }, { timeoutMs: badTimeout, fetchImpl: mockFetch(() => { forecastFetches += 1; return forecastBody(7); }) });
+    assert.equal(invalidForecast.ok, false);
+    assert.equal(forecastFetches, 0, `invalid forecast timeout ${String(badTimeout)} must not fetch`);
+    let climateFetches = 0;
+    const invalidClimateTimeout = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { timeoutMs: badTimeout, fetchImpl: mockFetch(() => { climateFetches += 1; return climateBody; }) });
+    assert.equal(invalidClimateTimeout.ok, false);
+    assert.equal(climateFetches, 0, `invalid climate timeout ${String(badTimeout)} must not fetch`);
+    let geoFetches = 0;
+    const invalidGeoTimeout = await geocodePlace('大理市', { timeoutMs: badTimeout, fetchImpl: mockFetch(() => { geoFetches += 1; return geoDali; }) });
+    assert.equal(invalidGeoTimeout.ok, false);
+    assert.equal(geoFetches, 0, `invalid geocode timeout ${String(badTimeout)} must not fetch`);
+}
+let cappedDays = '';
+const capped = await getForecast({ latitude: 25.6, longitude: 100.2 }, { days: 99, fetchImpl: async (input) => { cappedDays = String(input); return jsonResponse(forecastBody(16)); } });
+assert.equal(capped.ok, true);
+assert.match(cappedDays, /forecast_days=16/);
+const wrongMonth = await getClimate({ latitude: 25.6, longitude: 100.2 }, 9, { year: 2025, fetchImpl: mockFetch(() => climateBody) });
+assert.equal(wrongMonth.ok, false);
+const leapBody = { daily: { time: Array.from({ length: 29 }, (_, i) => `2024-02-${String(i + 1).padStart(2, '0')}`), temperature_2m_max: Array(29).fill(10), temperature_2m_min: Array(29).fill(1), weathercode: Array(29).fill(0) } };
+const leap = await getClimate({ latitude: 25.6, longitude: 100.2 }, 2, { year: 2024, fetchImpl: mockFetch(() => leapBody) });
+assert.equal(leap.ok, true);
+const historicalMinimum = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { year: 1940, fetchImpl: mockFetch(() => climateBodyFor(1940, 8)) });
+assert.equal(historicalMinimum.ok, true);
+const currentYear = new Date().getUTCFullYear();
+const currentClimate = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { year: currentYear, fetchImpl: mockFetch(() => climateBodyFor(currentYear, 8)) });
+assert.equal(currentClimate.ok, true);
+for (const badYear of [1939, 2025.5, currentYear + 1]) {
+    let yearFetches = 0;
+    const invalidYear = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { year: badYear, fetchImpl: mockFetch(() => { yearFetches += 1; return climateBody; }) });
+    assert.equal(invalidYear.ok, false);
+    assert.equal(yearFetches, 0, `invalid climate year ${String(badYear)} must not fetch`);
+}
+const duplicateDayBody = climateBodyFor(2025, 8);
+duplicateDayBody.daily.time[1] = duplicateDayBody.daily.time[0];
+const duplicateDay = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { year: 2025, fetchImpl: mockFetch(() => duplicateDayBody) });
+assert.equal(duplicateDay.ok, false);
+const day99Body = climateBodyFor(2025, 8);
+day99Body.daily.time[0] = '2025-08-99';
+const day99 = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { year: 2025, fetchImpl: mockFetch(() => day99Body) });
+assert.equal(day99.ok, false);
+let invalidClimateFetches = 0;
+const invalidClimate = await getClimate({ latitude: 25.6, longitude: 100.2 }, 13, { year: 2025, fetchImpl: mockFetch(() => { invalidClimateFetches += 1; return climateBody; }) });
+assert.equal(invalidClimate.ok, false);
+assert.equal(invalidClimateFetches, 0);
+let geoZeroFetches = 0;
+const geoZero = await geocodePlace('大理市', { timeoutMs: 0, fetchImpl: mockFetch(() => { geoZeroFetches += 1; return geoDali; }) });
+assert.equal(geoZero.ok, false);
+assert.equal(geoZeroFetches, 0);
+let climateZeroFetches = 0;
+const climateZero = await getClimate({ latitude: 25.6, longitude: 100.2 }, 8, { timeoutMs: 0, fetchImpl: mockFetch(() => { climateZeroFetches += 1; return climateBody; }) });
+assert.equal(climateZero.ok, false);
+assert.equal(climateZeroFetches, 0);
+let primaryResolutionFetches = 0;
+const originalPerformanceNow = performance.now;
+Object.defineProperty(performance, 'now', { configurable: true, value: (() => {
+        const values = [100, 104.5, 104.5];
+        return () => values.shift() ?? 104.5;
+    })() });
+try {
+    const primaryResolution = await geocodePlace('剩余不足一毫秒', { timeoutMs: 5, fetchImpl: mockFetch(() => { primaryResolutionFetches += 1; return geoDali; }) });
+    assert.equal(primaryResolution.ok, false);
+    assert.equal(primaryResolutionFetches, 0, 'sub-millisecond primary budget must not fetch');
+}
+finally {
+    Object.defineProperty(performance, 'now', { configurable: true, value: originalPerformanceNow });
+}
+let primaryBudgetFetches = 0;
+let fallbackResolutionFetches = 0;
+Object.defineProperty(performance, 'now', { configurable: true, value: (() => {
+        const values = [200, 200, 205];
+        return () => values.shift() ?? 205;
+    })() });
+try {
+    const fallbackResolution = await geocodePlace('兜底剩余不足一毫秒', { timeoutMs: 5, fetchImpl: async (input) => {
+            if (String(input).includes('nominatim')) {
+                fallbackResolutionFetches += 1;
+                return jsonResponse([]);
+            }
+            primaryBudgetFetches += 1;
+            return jsonResponse({ results: [] });
+        } });
+    assert.equal(fallbackResolution.ok, false);
+    assert.equal(primaryBudgetFetches, 1);
+    assert.equal(fallbackResolutionFetches, 0, 'sub-millisecond fallback budget must not fetch');
+}
+finally {
+    Object.defineProperty(performance, 'now', { configurable: true, value: originalPerformanceNow });
+}
+const nonErrorRejection = await getForecast({ latitude: 25.6, longitude: 100.2 }, { fetchImpl: async () => { throw Object.create(null); } });
+assert.equal(nonErrorRejection.ok, false);
+assert.equal(nonErrorRejection.error, 'request failed');
+const symbolRejection = await getForecast({ latitude: 25.6, longitude: 100.2 }, { fetchImpl: async () => { throw Symbol('untrusted'); } });
+assert.equal(symbolRejection.ok, false);
+assert.equal(symbolRejection.error, 'request failed');
+const originalDateNow = Date.now;
+Date.now = () => 0;
+try {
+    const rollback = await getForecast({ latitude: 25.6, longitude: 100.2 }, { timeoutMs: 20, fetchImpl: mockFetch(() => forecastBody(7)) });
+    assert.equal(rollback.ok, true, 'wall-clock rollback must not expand or break monotonic budget');
+}
+finally {
+    Date.now = originalDateNow;
+}
 assert.equal(wmoLabel(0), '晴');
 assert.equal(wmoLabel(95), '雷暴');
-assert.match(wmoLabel(999), /天气码999/, '未知码回退');
-console.log('5. WMO 码映射 OK');
-console.log('\nWEATHER TESTS: 5/5 OK(Open-Meteo 真实 API,免费无 key)');
-
-
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/weather-tests.ts
+assert.match(wmoLabel(999), /天气码999/);
+console.log('6. climate/schema guard/WMO OK');
+console.log('\nWEATHER TESTS: deterministic 6/6 OK (live APIs are peripheral smoke only)');

package/dist/scripts/wish-channel-gate-tests.js

@@ -0,0 +1,54 @@
+/**
+ * 愿望池通道否证测试(外部事件接缝第 2 段,issue #82 兼容方向;全离线纯函数):
+ *  1. conditions.channels 命名通道处于 down → 否证成行条件,即使 days/budget/month 全命中
+ *  2. 通道全健康(channelDown 空集)→ 不否证不加分,score/hits 与旧口径一致
+ *  3. ctx.channelDown 缺席(旧调用方)→ 行为与旧版完全一致(零破坏)
+ *  4. 畸形 channels(非数组/非字符串元素)→ 忽略,不误杀
+ *  5. pickNudgeWish 集成:最高分愿望被否证 → 次高分顶上(0..1 纪律不变)
+ *
+ * 运行: cd ts && npx tsx scripts/wish-channel-gate-tests.ts
+ */
+import assert from 'node:assert/strict';
+import { scoreWishMatch, pickNudgeWish } from '../src/wish-pool.js';
+const base = {
+    wish_id: 'w-dubai',
+    name: '迪拜',
+    added_at: '2026-09-01T00:00:00Z',
+    conditions: { days: 5, budget_cny: 8000, best_months: [10, 11], channels: ['hbcli-hotel'] },
+};
+// ── 1. 命名通道 down → 否证 ─────────────────────────────────────────────────
+const vetoed = scoreWishMatch(base, {
+    days: 10, budgetCny: 20000, month: 10,
+    channelDown: new Set(['hbcli-hotel']),
+});
+assert.equal(vetoed, null, 'days/budget/month 全命中但依赖通道 down → 否证返回 null');
+// ── 2. 通道健康 → 不否证不加分(评分口径不变,/3)────────────────────────────
+const healthy = scoreWishMatch(base, {
+    days: 10, budgetCny: 20000, month: 10,
+    channelDown: new Set(),
+});
+assert.ok(healthy && healthy.score === 3 && healthy.hits.join('+') === 'days≥5+budget≥8000+month=10', '健康时评分与旧口径一致(score=3)');
+// ── 3. channelDown 缺席(旧调用方)→ 零破坏 ──────────────────────────────────
+const legacy = scoreWishMatch(base, { days: 10, budgetCny: 20000, month: 10 });
+assert.ok(legacy && legacy.score === 3, '不传 channelDown 的旧调用行为不变');
+// ── 4. 畸形 channels 忽略 ────────────────────────────────────────────────────
+const malformed = scoreWishMatch({
+    ...base,
+    conditions: { days: 5, channels: 'hbcli-hotel' },
+}, { days: 10, month: 10, channelDown: new Set(['hbcli-hotel']) });
+assert.ok(malformed && malformed.score === 1, '非数组 channels 被忽略,不误杀');
+const mixed = scoreWishMatch({
+    ...base,
+    conditions: { days: 5, channels: [42, null, 'hbcli-hotel'] },
+}, { days: 10, month: 10, channelDown: new Set(['hbcli-hotel']) });
+assert.equal(mixed, null, '数组内字符串元素仍参与否证(非字符串忽略)');
+// ── 5. pickNudgeWish 集成:最高分被否证 → 次高顶上 ───────────────────────────
+const pool = [
+    { ...base, added_at: '2026-09-01T00:00:00Z' },
+    { wish_id: 'w-osaka', name: '大阪', added_at: '2026-09-02T00:00:00Z', conditions: { days: 5, best_months: [10] } },
+];
+const picked = pickNudgeWish(pool, { days: 10, month: 10, channelDown: new Set(['hbcli-hotel']) });
+assert.ok(picked && picked.wishId === 'w-osaka', `被否证的 w-dubai 退出,次高 w-osaka 顶上,实际 ${picked?.wishId}`);
+const none = pickNudgeWish([base], { days: 10, month: 10, channelDown: new Set(['hbcli-hotel']) });
+assert.equal(none, null, '全部被否证 → null(不硬推纪律保持)');
+console.log('WISH CHANNEL GATE TESTS: 5/5 OK(否证 / 健康不加分 / 旧调用零破坏 / 畸形忽略 / 0..1 集成)');