@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

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

@@ -1,31 +1,33 @@
+/**
+ * Turn routing & policy table tests (ADR-24 v2).
+ * 分类器是纯函数(Tier 0,零 LLM 零 IO),表测锁定 v1 规则面;
+ * 首条 fixture 是 2026-09-02 失败轨迹的用户原文——canonical 深规划
+ * case 必须命中 deep-planning,这是整个重设计的回归锚点。
+ */
 import assert from 'node:assert/strict';
-import { classifyTurn, extractTurnSignals, TURN_POLICIES, turnPolicyFor } from '../src/turn-policy.js';
-const TRAJECTORY_MESSAGE = '2026年我还有6天IRW额度 ,我准备再请几天假,在国内待个十几天。' + '其中10.3要去湖南衡阳参加同学婚礼。其他我没有特别的要求,请根据我的实际情况,偏好,外部环境等因素,给我安排行程';
+import { classifyTurn, extractTurnSignals, TURN_POLICIES, turnPolicyFor, } from '../src/turn-policy.js';
+// ---- 分类表(规则面快照) ---------------------------------------------------
+// 失败轨迹原文:13 天行程 + 10.3 婚礼 + 请假 + IRW → 必须转后台。
+const TRAJECTORY_MESSAGE = '2026年我还有6天IRW额度 ,我准备再请几天假,在国内待个十几天。'
+    + '其中10.3要去湖南衡阳参加同学婚礼。其他我没有特别的要求,请根据我的实际情况,偏好,外部环境等因素,给我安排行程';
 assert.equal(classifyTurn(TRAJECTORY_MESSAGE), 'deep-planning');
-assert.equal(classifyTurn('9.26到10.12在国内玩,中间要参加同学婚礼'), 'deep-planning');
-assert.equal(classifyTurn('国庆请假带父母去新疆,大概十几天'), 'deep-planning');
+assert.equal(classifyTurn('9.26到10.12在国内玩,中间要参加同学婚礼'), 'deep-planning'); // 双绝对日期+约束,跨度16天
+assert.equal(classifyTurn('国庆请假带父母去新疆,大概十几天'), 'deep-planning'); // 跨度词+双约束
 assert.equal(classifyTurn('帮我查一下明天深圳的天气'), 'quick');
 assert.equal(classifyTurn('你好'), 'quick');
-assert.equal(classifyTurn('帮我看看10.1去杭州的高铁票'), 'sync-planning');
-assert.equal(classifyTurn('3天后出发,帮我查下天气'), 'sync-planning');
-assert.equal(classifyTurn('把这段翻译成英文:会议纪要如下……省略若干字'.repeat(3)), 'sync-planning');
+assert.equal(classifyTurn('帮我看看10.1去杭州的高铁票'), 'sync-planning'); // 单日期零约束 → 默认中间档
+assert.equal(classifyTurn('3天后出发,帮我查下天气'), 'sync-planning'); // 短跨度词 → 不进 quick 也不进 deep
+assert.equal(classifyTurn('把这段翻译成英文:会议纪要如下……省略若干字'.repeat(3)), 'sync-planning'); // 长但零信号
+// ---- 信号提取 ---------------------------------------------------------------
 const full = extractTurnSignals('2026-10-03 出发');
-assert.deepEqual(full.absoluteDates, [
-    {
-        year: 2026,
-        month: 10,
-        day: 3
-    }
-]);
+assert.deepEqual(full.absoluteDates, [{ year: 2026, month: 10, day: 3 }]);
 const md = extractTurnSignals('10月3日到衡阳,10.5回深圳');
 assert.equal(md.absoluteDates.length, 2);
 assert.equal(md.spanDays, 2);
-assert.deepEqual(md.absoluteDates[0], {
-    year: null,
-    month: 10,
-    day: 3
-});
+assert.deepEqual(md.absoluteDates[0], { year: null, month: 10, day: 3 });
+// 无效月/日过滤;时间(冒号)与版本号外的数字不产日期
 assert.equal(extractTurnSignals('13.45 与 22:40 都是数字').absoluteDates.length, 0);
+// 跨度词:按强度取先
 assert.equal(extractTurnSignals('待十几天').spanDays, 12);
 assert.equal(extractTurnSignals('待半个月').spanDays, 15);
 assert.equal(extractTurnSignals('待一个月').spanDays, 30);
@@ -33,24 +35,21 @@ assert.equal(extractTurnSignals('大概两周').spanDays, 14);
 assert.equal(extractTurnSignals('大概一周').spanDays, 7);
 assert.equal(extractTurnSignals('还有6天额度').spanDays, 6);
 assert.equal(extractTurnSignals('没有跨度').spanDays, null);
+// 绝对日期 ≥2 时跨度词不参与
 const both = extractTurnSignals('10.1 到 10.9 玩十几天');
 assert.equal(both.spanDays, 8);
-assert.deepEqual(extractTurnSignals('婚礼加IRW,还要请假').constraintHits, [
-    '婚礼',
-    'IRW',
-    '请假'
-]);
+// 约束词:命中去重、按词表序
+assert.deepEqual(extractTurnSignals('婚礼加IRW,还要请假').constraintHits, ['婚礼', 'IRW', '请假']);
 assert.deepEqual(extractTurnSignals('没有任何约束词在这里').constraintHits, []);
-assert.equal(classifyTurn('10.3 婚礼那天衡阳天气怎么样?穿什么'), 'sync-planning');
+// user 消息里最常见的误触:quick 判据必须同时满足零日期/零约束/零跨度/短
+assert.equal(classifyTurn('10.3 婚礼那天衡阳天气怎么样?穿什么'), 'sync-planning'); // 有日期+约束 → 不冒进 quick
+// ---- policy 表 ---------------------------------------------------------------
 assert.equal(TURN_POLICIES['deep-planning'].exit, 'handoff');
 assert.equal(TURN_POLICIES['sync-planning'].exit, 'converge');
 assert.equal(TURN_POLICIES['quick'].exit, 'converge');
-for (const policy of Object.values(TURN_POLICIES)){
+for (const policy of Object.values(TURN_POLICIES)) {
     assert.ok(policy.hardMs > policy.softMs, 'hard must exceed soft');
     assert.ok(policy.softMs > 0 && policy.hardMs > 0);
 }
 assert.deepEqual(turnPolicyFor('quick'), TURN_POLICIES['quick']);
 console.log('turn policy tests: OK (routing table incl. trajectory verbatim, date/span extraction, policy shape)');
-
-
-//# sourceURL=ts/scripts/turn-policy-tests.ts

package/dist/scripts/typed-contract-canary.js

@@ -1,3 +1,22 @@
+/**
+ * D-30 普通模型 canary 运行器(issue #112 验收,tool-orchestration-design §4⑥)。
+ *
+ * 量什么:普通 LLM 面对投影后的工具 JSON Schema,能否**一次成型**产出合法参数——
+ * 这是 typed 参数契约迁移(D-30)要解决的核心问题(blob 时代强弱模型差距全部
+ * 暴露在「猜参数形状」上)。
+ *
+ * 怎么量:真实 LLM(env 三件套 LLM_API_KEY/LLM_BASE_URL/LLM_MODEL,或仓库 .env)
+ * + 工具投影 schema(defineTool 后的 parameters,与模型所见完全一致)+ tool_choice
+ * 强制单工具 → 模型出参 → `validateJsonSchemaValue`(与 dsh defineTool execute 前
+ * 同款校验)→ 违例为零 = 该例一次成型。
+ *
+ * 不执行工具:零检索副作用、零站点请求——canary 只量参数形态,不量业务结果。
+ *
+ * 达标线:工具调用一次成型率 ≥90%(10 例容 1 失);语义正确性(城市/日期/kind)
+ * 作为二级信号同报,不进门。
+ *
+ * 运行(在仓根或 ts/):LLM 三件套已配 → npx tsx ts/scripts/typed-contract-canary.ts
+ */
 import assert from 'node:assert/strict';
 import { readFileSync, existsSync, mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -6,6 +25,7 @@ import { fileURLToPath } from 'node:url';
 import { validateJsonSchemaValue } from '@deepseek-ai/dsh-tools';
 import { apply } from '../src/index.js';
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+// --- LLM 三件套:env 优先,回退仓库 .env(只取值,永不回显) ---
 function loadEnvTriple() {
     const env = process.env;
     let key = env.LLM_API_KEY ?? '';
@@ -13,95 +33,47 @@ function loadEnvTriple() {
     let model = env.LLM_MODEL ?? '';
     const envFile = join(ROOT, '.env');
     if (existsSync(envFile)) {
-        for (const line of readFileSync(envFile, 'utf-8').split('\n')){
+        for (const line of readFileSync(envFile, 'utf-8').split('\n')) {
             const m = /^([A-Z_]+)=(.*)$/.exec(line.trim());
-            if (!m) continue;
+            if (!m)
+                continue;
             const [, k, v] = m;
-            if (k === 'LLM_API_KEY' && !key) key = v.trim();
-            if (k === 'LLM_BASE_URL' && !base) base = v.trim();
-            if (k === 'LLM_MODEL' && !model) model = v.trim();
+            if (k === 'LLM_API_KEY' && !key)
+                key = v.trim();
+            if (k === 'LLM_BASE_URL' && !base)
+                base = v.trim();
+            if (k === 'LLM_MODEL' && !model)
+                model = v.trim();
         }
     }
     assert.ok(key && base && model, 'LLM_API_KEY/LLM_BASE_URL/LLM_MODEL 必须已配(env 或 .env)');
-    return {
-        key,
-        base,
-        model
-    };
+    return { key, base, model };
 }
+// --- 捕获插件注册表(隔离 stateRoot:canary 不写任何共享状态;sessionAccess=off 免审批) ---
 const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-canary-state-'));
 const registered = [];
 const ctx = {
-    tools: {
-        register: (t)=>registered.push(t)
-    },
-    systemPrompt: {
-        variable: ()=>()=>''
-    },
-    on: ()=>()=>{}
+    tools: { register: (t) => registered.push(t) },
+    systemPrompt: { variable: () => () => '' },
+    on: () => () => { },
 };
-apply(ctx, {
-    stateRoot,
-    timeoutMs: 30_000,
-    hbcliBin: 'hbcli-not-on-path',
-    sessionAccess: 'off'
-});
-const byName = (n)=>{
-    const t = registered.find((x)=>x.name === n);
+apply(ctx, { stateRoot, timeoutMs: 30_000, hbcliBin: 'hbcli-not-on-path', sessionAccess: 'off' });
+const byName = (n) => {
+    const t = registered.find(x => x.name === n);
     assert.ok(t, `工具 ${n} 应已注册`);
     return t;
 };
 const CASES = [
-    {
-        label: '机·票(城市对+日期)',
-        tool: 'gotry_flyai_search',
-        prompt: '帮我查一下 10 月 1 日从上海飞丽江的机票'
-    },
-    {
-        label: '火车票',
-        tool: 'gotry_flyai_search',
-        prompt: '10 月 1 日上海到昆明的火车票帮我查一下'
-    },
-    {
-        label: '酒店(带档期)',
-        tool: 'gotry_flyai_search',
-        prompt: '查一下大理 10 月 1 日入住、10 月 3 日退房的酒店'
-    },
-    {
-        label: '酒店(摸底,无档期)',
-        tool: 'gotry_flyai_search',
-        prompt: '先看看大理有哪些酒店'
-    },
-    {
-        label: '天气预报',
-        tool: 'gotry_weather_check',
-        prompt: '大理这几天天气怎么样'
-    },
-    {
-        label: '酒店实时源(hbcli)',
-        tool: 'gotry_hotel_search',
-        prompt: '查一下大理的酒店,入住下周五,住三晚'
-    },
-    {
-        label: '会话面机票(登录态)',
-        tool: 'gotry_session_search',
-        prompt: '用我的携程账号查 10 月 1 日上海到丽江的机票'
-    },
-    {
-        label: '目的地候选库',
-        tool: 'gotry_anything_search',
-        prompt: '大连在你们的目的地库里吗?帮我查一下'
-    },
-    {
-        label: 'GitHub 搜索',
-        tool: 'gotry_github_search',
-        prompt: '在 GitHub 上搜一下 agent-reach 这个项目'
-    },
-    {
-        label: '网页读取',
-        tool: 'gotry_web_search',
-        prompt: '帮我读一下 https://example.com 这个页面的内容'
-    }
+    { label: '机·票(城市对+日期)', tool: 'gotry_flyai_search', prompt: '帮我查一下 10 月 1 日从上海飞丽江的机票' },
+    { label: '火车票', tool: 'gotry_flyai_search', prompt: '10 月 1 日上海到昆明的火车票帮我查一下' },
+    { label: '酒店(带档期)', tool: 'gotry_flyai_search', prompt: '查一下大理 10 月 1 日入住、10 月 3 日退房的酒店' },
+    { label: '酒店(摸底,无档期)', tool: 'gotry_flyai_search', prompt: '先看看大理有哪些酒店' },
+    { label: '天气预报', tool: 'gotry_weather_check', prompt: '大理这几天天气怎么样' },
+    { label: '酒店实时源(hbcli)', tool: 'gotry_hotel_search', prompt: '查一下大理的酒店,入住下周五,住三晚' },
+    { label: '会话面机票(登录态)', tool: 'gotry_session_search', prompt: '用我的携程账号查 10 月 1 日上海到丽江的机票' },
+    { label: '目的地候选库', tool: 'gotry_anything_search', prompt: '大连在你们的目的地库里吗?帮我查一下' },
+    { label: 'GitHub 搜索', tool: 'gotry_github_search', prompt: '在 GitHub 上搜一下 agent-reach 这个项目' },
+    { label: '网页读取', tool: 'gotry_web_search', prompt: '帮我读一下 https://example.com 这个页面的内容' },
 ];
 async function callLlmMessages(cfg, toolName, messages) {
     const tool = byName(toolName);
@@ -109,32 +81,15 @@ async function callLlmMessages(cfg, toolName, messages) {
     const body = {
         model: cfg.model,
         messages,
-        tools: [
-            {
-                type: 'function',
-                function: {
-                    name: tool.name,
-                    description: tool.description,
-                    parameters: tool.parameters
-                }
-            }
-        ],
-        tool_choice: {
-            type: 'function',
-            function: {
-                name: tool.name
-            }
-        },
-        temperature: 0
+        tools: [{ type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.parameters } }],
+        tool_choice: { type: 'function', function: { name: tool.name } },
+        temperature: 0,
     };
     const res = await fetch(url, {
         method: 'POST',
-        headers: {
-            'content-type': 'application/json',
-            authorization: `Bearer ${cfg.key}`
-        },
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${cfg.key}` },
         body: JSON.stringify(body),
-        signal: AbortSignal.timeout(60_000)
+        signal: AbortSignal.timeout(60_000),
     });
     const bodyText = await res.text();
     assert.equal(res.status, 200, `LLM HTTP ${res.status}: ${bodyText.slice(0, 200)}`);
@@ -144,111 +99,74 @@ async function callLlmMessages(cfg, toolName, messages) {
     if (!tc?.function?.arguments) {
         const text = String(msg.content ?? '');
         assert.ok(/年份|日期|确认|2024|2025|2026/.test(text), `模型既未调工具也未按拒绝指引向用户确认: ${text.slice(0, 120)}`);
-        return {
-            args: undefined,
-            callId: 'text-reply',
-            text,
-            textReply: true
-        };
+        return { args: undefined, callId: 'text-reply', text, textReply: true };
     }
-    return {
-        args: JSON.parse(tc.function.arguments),
-        callId: tc.id ?? 'canary-call',
-        textReply: false
-    };
+    return { args: JSON.parse(tc.function.arguments), callId: tc.id ?? 'canary-call', textReply: false };
 }
 async function main() {
     const cfg = loadEnvTriple();
     console.log(`typed-contract canary:model=${cfg.model} 已配(值不回显);用例 ${CASES.length} 条,达标线 ≥90% 一次成型\n`);
     let pass = 0;
     const failures = [];
-    for (const c of CASES){
+    for (const c of CASES) {
         const tool = byName(c.tool);
         process.stdout.write(`- ${c.label} → ${c.tool} … `);
         try {
             const { args } = await callLlmMessages(cfg, c.tool, [
-                {
-                    role: 'system',
-                    content: '你是 GoTry 旅行助手。需要查数据时必须调用提供的工具,参数从用户话里取,不要编造。'
-                },
-                {
-                    role: 'user',
-                    content: c.prompt
-                }
+                { role: 'system', content: '你是 GoTry 旅行助手。需要查数据时必须调用提供的工具,参数从用户话里取,不要编造。' },
+                { role: 'user', content: c.prompt },
             ]);
             const violations = validateJsonSchemaValue(tool.parameters, args);
             if (violations.length === 0) {
                 pass++;
                 console.log(`PASS 一次成型 ${JSON.stringify(args).slice(0, 120)}`);
-            } else {
+            }
+            else {
                 failures.push(`${c.label}: schema 违例 ${violations.join(';')}`);
                 console.log(`FAIL schema 违例: ${violations.join(';').slice(0, 160)}`);
             }
-        } catch (e) {
+        }
+        catch (e) {
             failures.push(`${c.label}: ${e.message.slice(0, 160)}`);
             console.log(`FAIL ${e.message.slice(0, 140)}`);
         }
     }
+    // ---------------------------------------------------------------
+    // 验收②(issue #140):畸形/越界调用被宿主权拒绝后,模型按 violations 自纠。
+    // 确定性播种:预置一次带过去日期的被拒调用与结构化拒绝结果(tool 角色),
+    // 验证模型从拒绝中自纠出「schema 合规 + 日期非过去」的参数。只校验不执行(零副作用)。
+    // ---------------------------------------------------------------
     {
         const tool = byName('gotry_flyai_search');
         const today = new Date().toISOString().slice(0, 10);
         try {
             const messages = [
-                {
-                    role: 'system',
-                    content: '你是 GoTry 旅行助手。需要查数据时必须调用提供的工具,参数从用户话里取,不要编造。'
-                },
-                {
-                    role: 'user',
-                    content: '帮我查一下 10 月 1 日从上海飞丽江的机票'
-                },
-                {
-                    role: 'assistant',
-                    content: null,
-                    tool_calls: [
-                        {
-                            id: 'seed-reject',
-                            type: 'function',
-                            function: {
-                                name: 'gotry_flyai_search',
-                                arguments: JSON.stringify({
-                                    kind: 'flight',
-                                    from: '上海',
-                                    to: '丽江',
-                                    date: '2024-10-01'
-                                })
-                            }
-                        }
-                    ]
-                },
-                {
-                    role: 'tool',
-                    tool_call_id: 'seed-reject',
-                    content: JSON.stringify({
-                        ok: false,
-                        verdict: 'error',
-                        summary: `未发起查询:日期 2024-10-01 已是过去(今天 ${today}),过去不存在在售机票。多为用户时间表达未带年份所致——向用户确认年份(或按未来最近的同月日修正)后再查。`
-                    })
-                }
+                { role: 'system', content: '你是 GoTry 旅行助手。需要查数据时必须调用提供的工具,参数从用户话里取,不要编造。' },
+                { role: 'user', content: '帮我查一下 10 月 1 日从上海飞丽江的机票' },
+                { role: 'assistant', content: null, tool_calls: [{ id: 'seed-reject', type: 'function', function: { name: 'gotry_flyai_search', arguments: JSON.stringify({ kind: 'flight', from: '上海', to: '丽江', date: '2024-10-01' }) } }] },
+                { role: 'tool', tool_call_id: 'seed-reject', content: JSON.stringify({ ok: false, verdict: 'error', summary: `未发起查询:日期 2024-10-01 已是过去(今天 ${today}),过去不存在在售机票。多为用户时间表达未带年份所致——向用户确认年份(或按未来最近的同月日修正)后再查。` }) },
             ];
             const reply = await callLlmMessages(cfg, 'gotry_flyai_search', messages);
             const violations = reply.args ? validateJsonSchemaValue(tool.parameters, reply.args) : [];
             if (reply.textReply) {
                 assert.match(reply.text ?? '', /年份|日期|确认/, '文字形态应向用户确认年份/日期(契约允许的自纠)');
                 console.log('自纠回路(验收②):模型按拒绝指引转为向用户确认年份(文字形态,契约允许)');
-            } else {
+            }
+            else {
                 assert.equal(violations.length, 0, `自纠出参 schema 违例: ${violations.join(';')}`);
                 assert.ok(reply.args && reply.args.date && reply.args.date >= today, `自纠后日期应为今天或未来,实际 ${JSON.stringify(reply.args).slice(0, 80)}`);
                 console.log(`自纠回路(验收②):模型按拒绝自纠出参 → PASS(${JSON.stringify(reply.args).slice(0, 100)})`);
             }
-        } catch (e) {
+        }
+        catch (e) {
             failures.push(`验收② 自纠回路异常: ${e.message.slice(0, 140)}`);
             console.log(`FAIL 自纠回路异常(计入失败,不中断报告): ${e.message.slice(0, 140)}`);
         }
     }
-    const rate = Math.round(pass / CASES.length * 100);
+    const rate = Math.round((pass / CASES.length) * 100);
     console.log(`\n一次成型率:${pass}/${CASES.length} = ${rate}%(达标线 90%)`);
-    if (failures.length) console.log('失败明细:\n' + failures.map((f)=>`  - ${f}`).join('\n'));
+    if (failures.length)
+        console.log('失败明细:\n' + failures.map(f => `  - ${f}`).join('\n'));
     if (rate < 90) {
         console.error('TYPED CONTRACT CANARY FAIL(不达标不合入)');
         process.exit(1);
@@ -256,6 +174,3 @@ async function main() {
     console.log('TYPED CONTRACT CANARY OK');
 }
 await main();
-
-
-//# sourceURL=ts/scripts/typed-contract-canary.ts

package/dist/scripts/tz-resolver-sanity.js

@@ -0,0 +1,50 @@
+// Quick sanity check for tz-resolver. Run with: TZ=UTC npx tsx scripts/tz-resolver-sanity.ts
+import { resolveOffsetForLocalDate } from '../src/tz-resolver.js';
+const cases = [
+    // Asia/Shanghai has no DST throughout the year
+    ['Asia/Shanghai', '2026-07-18', '14:45', 480],
+    ['Asia/Shanghai', '2026-01-01', '09:00', 480],
+    ['Asia/Tokyo', '2026-07-04', '09:00', 540],
+    ['Asia/Hong_Kong', '2026-07-18', '14:45', 480],
+    ['Asia/Bangkok', '2026-08-09', '23:55', 420],
+    ['Asia/Singapore', '2026-08-09', '23:55', 480],
+    ['Asia/Dubai', '2026-07-18', '00:45', 240],
+    // America/New_York DST: EST = -5, EDT = -4. 2026 spring-forward = 2026-03-08, fall-back = 2026-11-01
+    ['America/New_York', '2026-03-07', '14:00', -300], // day before spring forward -> EST
+    ['America/New_York', '2026-03-09', '14:00', -240], // day after spring forward -> EDT
+    ['America/New_York', '2026-06-15', '09:00', -240], // summer -> EDT
+    ['America/New_York', '2026-12-15', '09:00', -300], // winter -> EST
+    ['America/Los_Angeles', '2026-06-15', '14:00', -420],
+    ['UTC', '2026-07-18', '12:00', 0],
+    ['Europe/London', '2026-06-15', '14:00', 60],
+    ['Europe/London', '2026-01-15', '14:00', 0],
+];
+let ok = 0, fail = 0;
+for (const [zone, ymd, hhmm, expected] of cases) {
+    const r = resolveOffsetForLocalDate(zone, ymd, hhmm);
+    const pass = r.ok && r.offsetMin === expected;
+    if (pass)
+        ok++;
+    else {
+        fail++;
+        console.log('FAIL', zone, ymd, hhmm, 'expected', expected, 'got', r.ok ? r.offsetMin : r);
+    }
+}
+const negatives = [
+    ['Foo/Bar', '2026-07-18', '14:45', 'unknown_zone'],
+    ['America/New_York', '2026-03-08', '02:30', 'gap_nonexistent'], // spring forward day
+    ['America/New_York', '2026-11-01', '01:30', 'overlap_ambiguous'], // fall back day
+];
+for (const [zone, ymd, hhmm, expected] of negatives) {
+    const r = resolveOffsetForLocalDate(zone, ymd, hhmm);
+    const pass = !r.ok && r.kind === expected;
+    if (pass)
+        ok++;
+    else {
+        fail++;
+        console.log('FAIL', zone, ymd, hhmm, 'expected', expected, 'got', r.ok ? `ok(${r.offsetMin})` : r.kind);
+    }
+}
+console.log(`\n${ok}/${ok + fail} sanity ok`);
+if (fail > 0)
+    process.exit(1);