@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/hearth/wake-proxy/__tests__/hearth-status-route.test.js

@@ -0,0 +1,372 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Readable } from 'node:stream';
+import { test } from 'node:test';
+import { routeRequest } from '../server.js';
+const ownerToken = 'owner-secret-token';
+const ownerTokenHash = createHash('sha256').update(ownerToken, 'utf8').digest('hex');
+const publicOrigin = 'https://hearth.example';
+function makeRuntime(tenantId, statePath) {
+    return {
+        proxy: {
+            host: '127.0.0.1',
+            port: 7878,
+            publicOrigin,
+            statePath,
+            m0RegistryPath: join(statePath, 'homes.json'),
+            ownerUserId: 'owner-user',
+            defaultTenantId: tenantId,
+            ownerTokenHash,
+            idlePauseMs: 60_000,
+            wakeTimeoutMs: 30_000,
+            readyTimeoutMs: 2_000,
+            cookieSecure: true,
+            seedHome: null,
+        },
+        m0: {
+            providerName: 'none',
+            registryPath: join(statePath, 'homes.json'),
+            guestUser: 'agent',
+            guestHome: '/home/agent',
+            guestCodePath: '/opt/crouter',
+            webPort: 7878,
+            nodeKind: 'general',
+            piPackages: [],
+            piAuthJson: null,
+            relayToken: null,
+        },
+    };
+}
+function writeState(statePath, tenantId) {
+    mkdirSync(join(statePath, '..'), { recursive: true });
+    writeFileSync(statePath, `${JSON.stringify({
+        version: 1,
+        owner: {
+            ownerUserId: 'owner-user',
+            defaultTenantId: tenantId,
+            tokenHash: ownerTokenHash,
+            createdAt: '2026-06-26T00:00:00.000Z',
+        },
+        tenants: {},
+    }, null, 2)}\n`, 'utf8');
+}
+function writeHome(registryPath, home) {
+    mkdirSync(join(registryPath, '..'), { recursive: true });
+    writeFileSync(registryPath, `${JSON.stringify({
+        [home.tenantId]: home,
+    }, null, 2)}\n`, 'utf8');
+}
+function makeRequest(method, url, headers = {}, body = '') {
+    const req = new Readable({ read() { } });
+    req.method = method;
+    req.url = url;
+    req.headers = headers;
+    process.nextTick(() => {
+        if (body !== '')
+            req.push(body);
+        req.push(null);
+    });
+    return req;
+}
+function makeResponse() {
+    return {
+        statusCode: 200,
+        headersSent: false,
+        headers: {},
+        body: '',
+        writeHead(statusCode, headers) {
+            this.statusCode = statusCode;
+            this.headers = { ...this.headers, ...headers };
+            this.headersSent = true;
+            return this;
+        },
+        setHeader(name, value) {
+            this.headers[name.toLowerCase()] = value;
+        },
+        end(chunk) {
+            if (chunk !== undefined)
+                this.body += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk;
+            this.headersSent = true;
+            return this;
+        },
+        destroy() {
+            this.headersSent = true;
+        },
+    };
+}
+function parseJsonBody(res) {
+    return JSON.parse(res.body);
+}
+test('status route returns 401 without owner auth', async () => {
+    const tenantId = 'tenant-status-unauthenticated';
+    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-unauth-'));
+    const statePath = join(tempDir, 'state.json');
+    writeState(statePath, tenantId);
+    const runtime = makeRuntime(tenantId, statePath);
+    const res = makeResponse();
+    const handled = await routeRequest(makeRequest('GET', '/__hearth/status'), res, runtime, {});
+    assert.equal(handled, undefined);
+    assert.equal(res.statusCode, 401);
+});
+test('status route returns runtime stats when existing relay already serves', async () => {
+    const tenantId = 'tenant-status-runtime';
+    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-runtime-'));
+    const statePath = join(tempDir, 'state.json');
+    const registryPath = join(tempDir, 'homes.json');
+    writeState(statePath, tenantId);
+    const runtime = makeRuntime(tenantId, statePath);
+    runtime.proxy.m0RegistryPath = registryPath;
+    runtime.m0.registryPath = registryPath;
+    const capturedAt = new Date().toISOString();
+    const fetchCalls = [];
+    writeHome(registryPath, {
+        tenantId,
+        providerName: 'none',
+        machineId: 'test-machine',
+        homeStorage: {
+            kind: 'volume',
+            durability: 'durable-volume',
+            longTermContract: true,
+            ownerMachineId: 'test-machine',
+            guestHome: '/home/agent',
+            volumeId: 'volume-123',
+            mountPath: '/home/agent',
+        },
+        state: 'running',
+        nodeId: 'test-node',
+        relayToken: 'relay-token',
+        webRoute: {
+            routeId: 'https://relay.example',
+            machineId: 'test-machine',
+            targetPort: 7878,
+            url: 'https://relay.example',
+            concreteUrl: 'https://relay.example',
+            concreteUrlSource: 'config',
+            createdAt: '2026-06-26T00:00:00.000Z',
+            raw: null,
+        },
+        createdAt: '2026-06-26T00:00:00.000Z',
+        updatedAt: '2026-06-26T00:00:00.000Z',
+    });
+    const res = makeResponse();
+    const handled = await routeRequest(makeRequest('GET', '/__hearth/status', { authorization: `Bearer ${ownerToken}` }), res, runtime, {
+        status: {
+            fetch: (async (url, init) => {
+                fetchCalls.push({ url: String(url), init: init ?? {} });
+                return {
+                    ok: true,
+                    status: 200,
+                    statusText: 'OK',
+                    async text() {
+                        return JSON.stringify({
+                            ok: true,
+                            exitCode: 0,
+                            stdout: JSON.stringify({
+                                cpuPct: 17.5,
+                                memoryUsedMB: 612,
+                                memoryAvailableMB: 1436,
+                                crtrRssKB: 45000,
+                                piRssKB: 32000,
+                                nodeRssKB: 12000,
+                                totalRssKB: 89000,
+                                capturedAt,
+                            }),
+                            stderr: '',
+                        });
+                    },
+                };
+            }),
+        },
+    });
+    assert.equal(handled, undefined);
+    assert.equal(res.statusCode, 200);
+    const body = parseJsonBody(res);
+    assert.equal(body.runtimeStats?.cpuPct, 17.5);
+    assert.equal(body.machineResources, null);
+    assert.equal(fetchCalls.length, 1);
+    assert.equal(fetchCalls[0]?.url, 'https://relay.example/__crtr/source');
+    assert.deepEqual(fetchCalls[0]?.init?.headers, {
+        authorization: 'Bearer relay-token',
+        'content-type': 'application/json',
+    });
+});
+test('status miss does not start wake/restore', async () => {
+    const tenantId = 'tenant-status-probe-fail';
+    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-probe-fail-'));
+    const statePath = join(tempDir, 'state.json');
+    const registryPath = join(tempDir, 'homes.json');
+    writeState(statePath, tenantId);
+    const runtime = makeRuntime(tenantId, statePath);
+    runtime.proxy.m0RegistryPath = registryPath;
+    runtime.m0.registryPath = registryPath;
+    writeHome(registryPath, {
+        tenantId,
+        providerName: 'none',
+        machineId: 'test-machine',
+        homeStorage: {
+            kind: 'volume',
+            durability: 'durable-volume',
+            longTermContract: true,
+            ownerMachineId: 'test-machine',
+            guestHome: '/home/agent',
+            volumeId: 'volume-123',
+            mountPath: '/home/agent',
+        },
+        state: 'running',
+        nodeId: 'test-node',
+        relayToken: 'relay-token',
+        webRoute: {
+            routeId: 'https://relay.example',
+            machineId: 'test-machine',
+            targetPort: 7878,
+            url: 'https://relay.example',
+            concreteUrl: 'https://relay.example',
+            concreteUrlSource: 'config',
+            createdAt: '2026-06-26T00:00:00.000Z',
+            raw: null,
+        },
+        createdAt: '2026-06-26T00:00:00.000Z',
+        updatedAt: '2026-06-26T00:00:00.000Z',
+    });
+    let guestSourceCalls = 0;
+    const fetchCalls = [];
+    const res = makeResponse();
+    const handled = await routeRequest(makeRequest('GET', '/__hearth/status', { authorization: `Bearer ${ownerToken}` }), res, runtime, {
+        status: {
+            fetch: (async (url, init) => {
+                fetchCalls.push({ url: String(url), init: init ?? {} });
+                return {
+                    ok: false,
+                    status: 503,
+                    statusText: 'Service Unavailable',
+                    async text() {
+                        return 'relay is down';
+                    },
+                };
+            }),
+            guestSource: async () => {
+                guestSourceCalls += 1;
+                throw new Error('guestSource should not run on a status miss');
+            },
+        },
+    });
+    assert.equal(handled, undefined);
+    assert.equal(res.statusCode, 200);
+    const body = parseJsonBody(res);
+    assert.equal(body.runtimeStats, null);
+    assert.equal(fetchCalls.length, 1);
+    assert.equal(fetchCalls[0]?.url, 'https://relay.example/__crtr/source');
+    assert.equal(guestSourceCalls, 0);
+});
+test('status route returns null runtime stats when the probe output is invalid JSON', async () => {
+    const tenantId = 'tenant-status-parse-fail';
+    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-parse-fail-'));
+    const statePath = join(tempDir, 'state.json');
+    const registryPath = join(tempDir, 'homes.json');
+    writeState(statePath, tenantId);
+    const runtime = makeRuntime(tenantId, statePath);
+    runtime.proxy.m0RegistryPath = registryPath;
+    runtime.m0.registryPath = registryPath;
+    writeHome(registryPath, {
+        tenantId,
+        providerName: 'none',
+        machineId: 'test-machine',
+        homeStorage: {
+            kind: 'volume',
+            durability: 'durable-volume',
+            longTermContract: true,
+            ownerMachineId: 'test-machine',
+            guestHome: '/home/agent',
+            volumeId: 'volume-123',
+            mountPath: '/home/agent',
+        },
+        state: 'running',
+        nodeId: 'test-node',
+        relayToken: 'relay-token',
+        webRoute: {
+            routeId: 'https://relay.example',
+            machineId: 'test-machine',
+            targetPort: 7878,
+            url: 'https://relay.example',
+            concreteUrl: 'https://relay.example',
+            concreteUrlSource: 'config',
+            createdAt: '2026-06-26T00:00:00.000Z',
+            raw: null,
+        },
+        createdAt: '2026-06-26T00:00:00.000Z',
+        updatedAt: '2026-06-26T00:00:00.000Z',
+    });
+    const res = makeResponse();
+    const handled = await routeRequest(makeRequest('GET', '/__hearth/status', { authorization: `Bearer ${ownerToken}` }), res, runtime, {
+        status: {
+            fetch: (async () => ({
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                async text() {
+                    return 'not json';
+                },
+            })),
+        },
+    });
+    assert.equal(handled, undefined);
+    assert.equal(res.statusCode, 200);
+    const body = parseJsonBody(res);
+    assert.equal(body.runtimeStats, null);
+});
+test('status route returns machine resources from getMachine', async () => {
+    const tenantId = 'tenant-status-machine';
+    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-status-machine-'));
+    const statePath = join(tempDir, 'state.json');
+    const registryPath = join(tempDir, 'homes.json');
+    writeState(statePath, tenantId);
+    writeFileSync(registryPath, `${JSON.stringify({
+        [tenantId]: {
+            tenantId,
+            providerName: 'none',
+            machineId: 'test-machine',
+            homeStorage: {
+                kind: 'volume',
+                durability: 'durable-volume',
+                longTermContract: true,
+                ownerMachineId: 'test-machine',
+                guestHome: '/home/agent',
+                volumeId: 'volume-123',
+                mountPath: '/home/agent',
+            },
+            state: 'running',
+            createdAt: '2026-06-26T00:00:00.000Z',
+            updatedAt: '2026-06-26T00:00:00.000Z',
+        },
+    }, null, 2)}\n`, 'utf8');
+    const runtime = makeRuntime(tenantId, statePath);
+    runtime.proxy.m0RegistryPath = registryPath;
+    runtime.m0.registryPath = registryPath;
+    const getMachine = async (machineId) => {
+        assert.equal(machineId, 'test-machine');
+        return {
+            providerName: 'none',
+            machineId: 'test-machine',
+            state: 'running',
+            raw: {
+                cpuCount: 2,
+                memoryMB: 2048,
+                status: 'running',
+            },
+        };
+    };
+    const res = makeResponse();
+    const handled = await routeRequest(makeRequest('GET', '/__hearth/status', { authorization: `Bearer ${ownerToken}` }), res, runtime, {
+        status: {
+            getMachine,
+            guestSource: async () => ({ ok: false, stdout: '', stderr: 'timeout' }),
+        },
+    });
+    assert.equal(handled, undefined);
+    assert.equal(res.statusCode, 200);
+    const body = parseJsonBody(res);
+    assert.deepEqual(body.machineResources, { cpuCount: 2, memoryMB: 2048 });
+});

package/dist/hearth/wake-proxy/__tests__/http-running-route-fast-path.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hearth/wake-proxy/__tests__/http-running-route-fast-path.test.js

@@ -0,0 +1,258 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { configureWakeProxyRuntime, wakeProxyInternals } from '../home.js';
+import { proxyHttpRequest } from '../proxy.js';
+// Regression for the HTTP wake-path 502/asset-timeout (hearth-soak-4a0dc43-report.md §4): every HTTP
+// forward routed through ensureAwake, so a single momentary slow `probeRelayServing` under guest
+// load false-negatived and escalated the request into the 150s wakeHome/waitForRelayReady
+// path (serial guest execs) — while the direct route was returning 200 in ~0.1s the whole
+// time. The fix: a home crtr already records `running` with a route+token is forwarded DIRECTLY (the
+// forward is the liveness check); ensureAwake/restore is reserved for missing/not-running state or a
+// clear upstream failure. These tests fail on the pre-fix code that gated all HTTP through ensureAwake.
+const tenantId = 'silas';
+const machineId = 'igd2fkrn1y1ol3vw5i6mt';
+const nodeId = 'mqt64sus-e71caa94';
+const routeUrl = 'https://7878-igd2fkrn1y1ol3vw5i6mt.example.dev';
+const ownerToken = 'owner-secret-token';
+const now = '2026-06-25T00:00:00.000Z';
+function makeHome(overrides = {}) {
+    return {
+        tenantId,
+        providerName: 'none',
+        machineId,
+        homeStorage: {
+            kind: 'volume',
+            durability: 'durable-volume',
+            longTermContract: true,
+            ownerMachineId: machineId,
+            guestHome: '/home/agent',
+            volumeId: '48b59d07-8cc9-46f9-bdfd-ac99a55dff40',
+            mountPath: '/home/agent',
+        },
+        state: 'running',
+        nodeId,
+        relayToken: 'relay-token',
+        webRoute: {
+            routeId: '7878-igd2fkrn1y1ol3vw5i6mt.example.dev',
+            machineId,
+            targetPort: 7878,
+            url: routeUrl,
+            concreteUrl: routeUrl,
+            concreteUrlSource: 'provider',
+            createdAt: now,
+            raw: null,
+        },
+        createdAt: now,
+        updatedAt: now,
+        ...overrides,
+    };
+}
+function makeRuntime(registryPath, statePath) {
+    return {
+        proxy: {
+            host: '127.0.0.1',
+            port: 7878,
+            publicOrigin: 'https://hearth-wake-proxy.fly.dev',
+            statePath,
+            m0RegistryPath: registryPath,
+            ownerUserId: 'owner-user',
+            defaultTenantId: tenantId,
+            ownerTokenHash: createHash('sha256').update(ownerToken, 'utf8').digest('hex'),
+            idlePauseMs: 0,
+            wakeTimeoutMs: 30_000,
+            readyTimeoutMs: 2_000,
+            cookieSecure: true,
+            seedHome: null,
+        },
+        m0: {
+            providerName: 'none',
+            registryPath,
+            guestUser: 'agent',
+            guestHome: '/home/agent',
+            guestCodePath: '/opt/crouter',
+            webPort: 7878,
+            nodeKind: 'general',
+            piPackages: [],
+            piAuthJson: null,
+            relayToken: null,
+        },
+    };
+}
+function setup(home = makeHome()) {
+    const tempDir = mkdtempSync(join(tmpdir(), 'crouter-hearth-http-fast-'));
+    const registryPath = join(tempDir, 'homes.json');
+    const statePath = join(tempDir, 'state.json');
+    writeFileSync(registryPath, `${JSON.stringify({ [tenantId]: home }, null, 2)}\n`, 'utf8');
+    const runtime = makeRuntime(registryPath, statePath);
+    configureWakeProxyRuntime(runtime);
+    return runtime;
+}
+class FakeReq extends EventEmitter {
+    url;
+    method;
+    headers;
+    constructor(path, method = 'GET') {
+        super();
+        this.url = path;
+        this.method = method;
+        this.headers = { authorization: `Bearer ${ownerToken}`, host: 'hearth-wake-proxy.fly.dev' };
+    }
+}
+class FakeRes extends EventEmitter {
+    statusCode = 200;
+    statusMessage = '';
+    headersSent = false;
+    writableEnded = false;
+    headers = new Map();
+    chunks = [];
+    socket = { setNoDelay() { } };
+    setHeader(name, value) {
+        this.headers.set(name.toLowerCase(), value);
+    }
+    getHeader(name) {
+        return this.headers.get(name.toLowerCase());
+    }
+    hasHeader(name) {
+        return this.headers.has(name.toLowerCase());
+    }
+    writeHead(code, headers) {
+        this.statusCode = code;
+        this.headersSent = true;
+        if (headers)
+            for (const [k, v] of Object.entries(headers))
+                this.setHeader(k, v);
+    }
+    flushHeaders() {
+        this.headersSent = true;
+    }
+    write(chunk) {
+        this.headersSent = true;
+        this.chunks.push(Buffer.from(chunk));
+        return true;
+    }
+    end(chunk) {
+        this.headersSent = true;
+        if (chunk !== undefined)
+            this.chunks.push(Buffer.from(chunk));
+        this.writableEnded = true;
+        this.emit('finish');
+    }
+    destroy() {
+        this.writableEnded = true;
+    }
+    body() {
+        return Buffer.concat(this.chunks).toString('utf8');
+    }
+}
+function asReq(req) {
+    return req;
+}
+function asRes(res) {
+    return res;
+}
+function htmlResponse(text) {
+    return new Response(text, { status: 200, headers: { 'content-type': 'text/html; charset=utf-8' } });
+}
+function guardHeavyPath(t) {
+    const probe = t.mock.method(wakeProxyInternals, 'probeRelayServing', async () => {
+        throw new Error('probeRelayServing must not run on the running-route fast path');
+    });
+    const wake = t.mock.method(wakeProxyInternals, 'wakeHome', async () => {
+        throw new Error('wakeHome must not run on the running-route fast path');
+    });
+    return { probe, wake };
+}
+test('HTTP request against a known-running route forwards directly without the heavy wake/restore path', async (t) => {
+    const runtime = setup();
+    const { probe, wake } = guardHeavyPath(t);
+    const fetchMock = t.mock.method(globalThis, 'fetch', async () => htmlResponse('<html>chat</html>'));
+    const res = new FakeRes();
+    await proxyHttpRequest(asReq(new FakeReq('/views/chat')), asRes(res), runtime);
+    assert.equal(res.statusCode, 200);
+    assert.equal(res.body(), '<html>chat</html>');
+    assert.equal(fetchMock.mock.callCount(), 1);
+    // The forward went straight to the persisted route — never through ensureAwake's probe/wake.
+    assert.equal(probe.mock.callCount(), 0);
+    assert.equal(wake.mock.callCount(), 0);
+});
+test('concurrent asset/page requests forward in parallel without serializing behind a slow guest probe', async (t) => {
+    const runtime = setup();
+    const { probe, wake } = guardHeavyPath(t);
+    let inFlight = 0;
+    let maxInFlight = 0;
+    let release;
+    const gate = new Promise((resolve) => {
+        release = resolve;
+    });
+    const fetchMock = t.mock.method(globalThis, 'fetch', async () => {
+        inFlight += 1;
+        maxInFlight = Math.max(maxInFlight, inFlight);
+        await gate;
+        inFlight -= 1;
+        return htmlResponse('<html>asset</html>');
+    });
+    const paths = ['/views/chat', '/assets/index-a.css', '/assets/index-b.js', '/assets/index-c.js', '/favicon.svg'];
+    const responses = paths.map(() => new FakeRes());
+    const calls = paths.map((p, i) => proxyHttpRequest(asReq(new FakeReq(p)), asRes(responses[i]), runtime));
+    // Let all five enter forwardUpstream before any resolves; if they serialized behind a per-tenant
+    // wake lock/probe, only one would be in flight here.
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    const concurrentBeforeRelease = maxInFlight;
+    release();
+    await Promise.all(calls);
+    assert.equal(concurrentBeforeRelease, paths.length);
+    assert.equal(fetchMock.mock.callCount(), paths.length);
+    for (const res of responses) {
+        assert.equal(res.statusCode, 200);
+        assert.equal(res.body(), '<html>asset</html>');
+    }
+    assert.equal(probe.mock.callCount(), 0);
+    assert.equal(wake.mock.callCount(), 0);
+});
+test('a clear upstream failure against the running route invalidates the verdict and wakes deliberately', async (t) => {
+    const runtime = setup();
+    // ensureAwake's deliberate wake path: the route IS serving (probe true), so it confirms via the
+    // cheap probe and never restores — the point is that the failed direct forward ESCALATED into
+    // ensureAwake rather than silently 502ing.
+    const probe = t.mock.method(wakeProxyInternals, 'probeRelayServing', async () => true);
+    const wake = t.mock.method(wakeProxyInternals, 'wakeHome', async () => {
+        throw new Error('wakeHome must not run when the relay is serving');
+    });
+    t.mock.method(wakeProxyInternals, 'touchTenantWake', async () => undefined);
+    let fetchCalls = 0;
+    const fetchMock = t.mock.method(globalThis, 'fetch', async () => {
+        fetchCalls += 1;
+        if (fetchCalls === 1)
+            throw new TypeError('fetch failed'); // connection refused against stale route
+        return htmlResponse('<html>recovered</html>');
+    });
+    const res = new FakeRes();
+    await proxyHttpRequest(asReq(new FakeReq('/views/chat')), asRes(res), runtime);
+    assert.equal(res.statusCode, 200);
+    assert.equal(res.body(), '<html>recovered</html>');
+    assert.equal(fetchMock.mock.callCount(), 2); // direct forward failed, deliberate wake forward succeeded
+    assert.equal(probe.mock.callCount(), 1); // entered ensureAwake exactly once
+    assert.equal(wake.mock.callCount(), 0);
+});
+test('not-running home skips the fast path and goes straight to the deliberate wake', async (t) => {
+    const runtime = setup(makeHome({ state: 'paused' }));
+    const probe = t.mock.method(wakeProxyInternals, 'probeRelayServing', async () => true);
+    const wake = t.mock.method(wakeProxyInternals, 'wakeHome', async () => {
+        throw new Error('wakeHome must not run when the relay is serving');
+    });
+    t.mock.method(wakeProxyInternals, 'touchTenantWake', async () => undefined);
+    const fetchMock = t.mock.method(globalThis, 'fetch', async () => htmlResponse('<html>woke</html>'));
+    const res = new FakeRes();
+    await proxyHttpRequest(asReq(new FakeReq('/views/chat')), asRes(res), runtime);
+    assert.equal(res.statusCode, 200);
+    assert.equal(res.body(), '<html>woke</html>');
+    // Paused home is not trusted directly — it must enter ensureAwake (probe runs) before forwarding.
+    assert.equal(probe.mock.callCount(), 1);
+    assert.equal(wake.mock.callCount(), 0);
+    assert.equal(fetchMock.mock.callCount(), 1);
+});

package/dist/hearth/wake-proxy/__tests__/model-auth-routes.test.d.ts

@@ -0,0 +1 @@
+export {};