@danceiny/gotry 0.0.1-rc.15 → 0.0.1-rc.17

package/dist/capabilities/session/extension-distribution.js

@@ -0,0 +1,234 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const DIST_ASSET_TARBALL = 'gotry-session-bridge.tar.gz';
+export const DIST_ASSET_STORE_ZIP = 'gotry-session-bridge-store.zip';
+export const DIST_ASSET_MANIFEST = 'extension-dist-manifest.json';
+export const DEFAULT_RELEASE_BASE = 'https://github.com/Danceiny/gotry/releases';
+export function compareVersions(a, b) {
+    const pa = String(a).split('.').map((s)=>Number.parseInt(s, 10) || 0);
+    const pb = String(b).split('.').map((s)=>Number.parseInt(s, 10) || 0);
+    const n = Math.max(pa.length, pb.length);
+    for(let i = 0; i < n; i += 1){
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0) return d;
+    }
+    return 0;
+}
+export function distAssetUrls(releaseBase = DEFAULT_RELEASE_BASE) {
+    const base = releaseBase.replace(/\/+$/, '');
+    return {
+        tarball: `${base}/latest/download/${DIST_ASSET_TARBALL}`,
+        storeZip: `${base}/latest/download/${DIST_ASSET_STORE_ZIP}`,
+        manifest: `${base}/latest/download/${DIST_ASSET_MANIFEST}`
+    };
+}
+const SHA256_RE = /^[0-9a-f]{64}$/;
+export function parseDistManifest(raw) {
+    let obj;
+    try {
+        obj = JSON.parse(raw);
+    } catch  {
+        throw new Error('dist-manifest 不是合法 JSON');
+    }
+    const version = obj.version;
+    const tarball = obj.tarball;
+    const tarballSha256 = obj.tarballSha256;
+    const zip = obj.zip;
+    const zipSha256 = obj.zipSha256;
+    if (typeof version !== 'string' || !/^\d+\.\d+\.\d+$/.test(version)) throw new Error('dist-manifest.version 缺失或非 x.y.z');
+    if (tarball !== DIST_ASSET_TARBALL) throw new Error(`dist-manifest.tarball 资产名漂移(期望 ${DIST_ASSET_TARBALL})`);
+    if (zip !== DIST_ASSET_STORE_ZIP) throw new Error(`dist-manifest.zip 资产名漂移(期望 ${DIST_ASSET_STORE_ZIP})`);
+    if (typeof tarballSha256 !== 'string' || !SHA256_RE.test(tarballSha256)) throw new Error('dist-manifest.tarballSha256 非 64-hex');
+    if (typeof zipSha256 !== 'string' || !SHA256_RE.test(zipSha256)) throw new Error('dist-manifest.zipSha256 非 64-hex');
+    return {
+        version,
+        tarball,
+        tarballSha256,
+        zip,
+        zipSha256,
+        builtFromCommit: typeof obj.builtFromCommit === 'string' ? obj.builtFromCommit : undefined
+    };
+}
+export function sha256Hex(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+export function readExtensionKey(extensionDir) {
+    const p = join(extensionDir, 'manifest.json');
+    if (!existsSync(p)) return undefined;
+    try {
+        const m = JSON.parse(readFileSync(p, 'utf8'));
+        return typeof m.key === 'string' ? m.key : undefined;
+    } catch  {
+        return undefined;
+    }
+}
+export function readExtensionVersion(extensionDir) {
+    const p = join(extensionDir, 'manifest.json');
+    if (!existsSync(p)) return undefined;
+    try {
+        const m = JSON.parse(readFileSync(p, 'utf8'));
+        return typeof m.version === 'string' ? m.version : undefined;
+    } catch  {
+        return undefined;
+    }
+}
+function runTar(args, spawnFn, timeoutMs) {
+    return new Promise((resolve)=>{
+        const child = spawnFn('tar', args, {
+            stdio: 'ignore'
+        });
+        let done = false;
+        const timer = setTimeout(()=>{
+            if (!done) {
+                done = true;
+                try {
+                    child.kill('SIGKILL');
+                } catch  {}
+                resolve({
+                    ok: false,
+                    error: `tar 超时(>${timeoutMs}ms)`
+                });
+            }
+        }, timeoutMs);
+        child.on('error', (e)=>{
+            if (!done) {
+                done = true;
+                clearTimeout(timer);
+                resolve({
+                    ok: false,
+                    error: `tar 不可用:${e.message}`
+                });
+            }
+        });
+        child.on('close', (code)=>{
+            if (!done) {
+                done = true;
+                clearTimeout(timer);
+                resolve(code === 0 ? {
+                    ok: true
+                } : {
+                    ok: false,
+                    error: `tar exit ${code}`
+                });
+            }
+        });
+    });
+}
+async function fetchBytes(url, fetchFn, timeoutMs) {
+    try {
+        const res = await fetchFn(url, {
+            signal: AbortSignal.timeout(timeoutMs)
+        });
+        if (!res.ok) return {
+            ok: false,
+            error: `HTTP ${res.status} ${url}`
+        };
+        const buf = new Uint8Array(await res.arrayBuffer());
+        return {
+            ok: true,
+            bytes: buf
+        };
+    } catch (e) {
+        return {
+            ok: false,
+            error: `下载失败 ${e.message}`
+        };
+    }
+}
+export async function installExtensionFromGithub(opts) {
+    const timeoutMs = opts.timeoutMs ?? 60_000;
+    const fetchFn = opts.fetch ?? fetch;
+    const spawnFn = opts.spawnFn ?? spawn;
+    const urls = distAssetUrls(opts.releaseBase);
+    const fail = (error)=>({
+            ok: false,
+            action: 'fallback-bundled',
+            error
+        });
+    const mRes = await fetchBytes(urls.manifest, fetchFn, timeoutMs);
+    if (!mRes.ok) return fail(mRes.error);
+    let manifest;
+    try {
+        manifest = parseDistManifest(new TextDecoder().decode(mRes.bytes));
+    } catch (e) {
+        return fail(`dist-manifest 校验失败:${e.message}`);
+    }
+    const previousVersion = readExtensionVersion(opts.destDir);
+    if (previousVersion != null && compareVersions(manifest.version, previousVersion) <= 0) {
+        return {
+            ok: true,
+            action: 'up-to-date',
+            version: manifest.version,
+            previousVersion
+        };
+    }
+    if (opts.checkOnly) {
+        return {
+            ok: true,
+            action: 'up-to-date',
+            version: manifest.version,
+            previousVersion
+        };
+    }
+    const tRes = await fetchBytes(urls.tarball, fetchFn, timeoutMs);
+    if (!tRes.ok) return fail(tRes.error);
+    const actual = sha256Hex(tRes.bytes);
+    if (actual !== manifest.tarballSha256) return fail(`SHA256 不符(期望 ${manifest.tarballSha256.slice(0, 12)}… 实得 ${actual.slice(0, 12)}…)`);
+    const incoming = `${opts.destDir}.incoming-${process.pid}-${Date.now()}`;
+    const tarPath = `${incoming}.tar.gz`;
+    try {
+        rmSync(incoming, {
+            recursive: true,
+            force: true
+        });
+        mkdirSync(incoming, {
+            recursive: true
+        });
+        writeFileSync(tarPath, tRes.bytes);
+        const ext = await runTar([
+            '-xzf',
+            tarPath,
+            '-C',
+            incoming,
+            '--strip-components',
+            '1'
+        ], spawnFn, timeoutMs);
+        if (!ext.ok) return fail(ext.error);
+        const incomingKey = readExtensionKey(incoming);
+        if (incomingKey == null) return fail('解压产物缺 manifest.json/key(非法包)');
+        if (opts.pinnedSourceDir) {
+            const pinnedKey = readExtensionKey(opts.pinnedSourceDir);
+            if (pinnedKey != null && incomingKey !== pinnedKey) return fail('扩展 key 漂移(通道产物与 bundled 不同 ID——拒绝安装,防端口池/host 权限漂移)');
+        }
+        const incomingVersion = readExtensionVersion(incoming);
+        if (incomingVersion !== manifest.version) return fail(`解压产物版本(${incomingVersion})与 dist-manifest(${manifest.version})不符`);
+        rmSync(opts.destDir, {
+            recursive: true,
+            force: true
+        });
+        cpSync(incoming, opts.destDir, {
+            recursive: true
+        });
+        return {
+            ok: true,
+            action: 'installed',
+            version: manifest.version,
+            previousVersion
+        };
+    } catch (e) {
+        return fail(`落位失败 ${e.message}`);
+    } finally{
+        rmSync(incoming, {
+            recursive: true,
+            force: true
+        });
+        rmSync(tarPath, {
+            force: true
+        });
+    }
+}
+
+
+//# sourceURL=ts/capabilities/session/extension-distribution.ts

package/dist/capabilities/session/extract.js

@@ -37,4 +37,4 @@ export function nameAffinity(a, b) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/extract.ts
+//# sourceURL=ts/capabilities/session/extract.ts

package/dist/capabilities/session/golden-score.js

@@ -0,0 +1,92 @@
+import { SESSION_FIELD_ACCURACY_THRESHOLD } from './benchmark.js';
+function parseHHmm(value) {
+    const [hours, minutes] = value.split(':');
+    return parseInt(hours, 10) * 60 + parseInt(minutes, 10);
+}
+function parseLocalMinutes(value) {
+    const match = value.match(/(\d{2}):(\d{2})/);
+    if (!match) return null;
+    return parseInt(match[1], 10) * 60 + parseInt(match[2], 10);
+}
+function parseLocalDate(value) {
+    return value.match(/^(\d{4}-\d{2}-\d{2})[T ]/)?.[1] ?? null;
+}
+export function scoreSessionAgainstGoldenBand(session, band, goldenSource) {
+    const missing = [];
+    const hardIncorrect = [];
+    const segment = session.route_segments[0];
+    if (!session.query_id) missing.push('query_id');
+    else if (session.query_id !== band.query_id) hardIncorrect.push('query_id');
+    if (!session.currency) missing.push('currency');
+    else if (session.currency !== 'CNY') hardIncorrect.push('currency');
+    if (!session.source) missing.push('source');
+    else if (session.source !== 'ctrip-flight') hardIncorrect.push('source');
+    if (!session.verdict) missing.push('verdict');
+    else if (session.verdict !== 'hit') hardIncorrect.push('verdict');
+    if (!segment) {
+        missing.push('route_segments[0].from', 'route_segments[0].to', 'route_segments[0].departure_at', 'route_segments[0].arrival_at', 'route_segments[0].transport_number');
+    } else {
+        if (!segment.from) missing.push('route_segments[0].from');
+        else if (segment.from !== band.from) hardIncorrect.push('route_segments[0].from');
+        if (!segment.to) missing.push('route_segments[0].to');
+        else if (segment.to !== band.to) hardIncorrect.push('route_segments[0].to');
+        if (!segment.departure_at) missing.push('route_segments[0].departure_at');
+        else if (parseLocalDate(segment.departure_at) !== band.date) {
+            hardIncorrect.push('route_segments[0].departure_at.date');
+        }
+        if (!segment.arrival_at) missing.push('route_segments[0].arrival_at');
+        else if (parseLocalDate(segment.arrival_at) !== band.date) {
+            hardIncorrect.push('route_segments[0].arrival_at.date');
+        }
+        if (!segment.transport_number) missing.push('route_segments[0].transport_number');
+    }
+    const softChecks = [];
+    if (segment?.departure_at) {
+        const minutes = parseLocalMinutes(segment.departure_at);
+        softChecks.push({
+            path: 'route_segments[0].departure_at',
+            ok: minutes !== null && minutes >= parseHHmm(band.window_dep_local.earliest) && minutes <= parseHHmm(band.window_dep_local.latest)
+        });
+    }
+    if (segment?.arrival_at) {
+        const minutes = parseLocalMinutes(segment.arrival_at);
+        softChecks.push({
+            path: 'route_segments[0].arrival_at',
+            ok: minutes !== null && minutes >= parseHHmm(band.window_arr_local.earliest) && minutes <= parseHHmm(band.window_arr_local.latest)
+        });
+    }
+    if (segment?.transport_number) {
+        const actual = segment.transport_number.toUpperCase();
+        softChecks.push({
+            path: 'route_segments[0].transport_number',
+            ok: band.known_flights.some((flight)=>actual.startsWith(flight.toUpperCase())) || band.known_flights.some((flight)=>actual.includes(flight.toUpperCase().slice(0, 2)))
+        });
+    }
+    if (Number.isFinite(session.price) && session.price > 0) {
+        const margin = band.price_cny.max * 0.15;
+        softChecks.push({
+            path: 'price',
+            ok: session.price >= band.price_cny.min - margin && session.price <= band.price_cny.max + margin
+        });
+    } else missing.push('price');
+    const softIncorrect = softChecks.filter((check)=>!check.ok).map((check)=>check.path);
+    const incorrect = [
+        ...hardIncorrect,
+        ...softIncorrect
+    ];
+    const total = 13;
+    const correct = Math.max(0, total - new Set(missing).size - incorrect.length);
+    const accuracy = total > 0 ? correct / total : 0;
+    return {
+        pass: missing.length === 0 && hardIncorrect.length === 0 && accuracy >= SESSION_FIELD_ACCURACY_THRESHOLD,
+        total,
+        correct,
+        accuracy,
+        missing: Array.from(new Set(missing)),
+        incorrect,
+        golden_source: goldenSource
+    };
+}
+
+
+//# sourceURL=ts/capabilities/session/golden-score.ts

package/dist/capabilities/session/health-watch.js

@@ -0,0 +1,216 @@
+import { request } from 'node:http';
+import { BRIDGE_PORTS, EXTENSION_CONNECTED_WINDOW_MS } from './extension-bridge.js';
+export async function combinedProbe(opts, businessProbe) {
+    if (!await defaultProbe(opts)) return false;
+    if (!businessProbe) return true;
+    try {
+        const channel = await import('./extension-channel.js');
+        const bridge = await import('./extension-bridge.js');
+        bridge.getOrCreateSessionBridge({
+            keepBridge: opts.keepBridge === true
+        });
+        const cookie = await channel.extensionCookieNames({
+            site: 'ctrip-flight',
+            domain: 'ctrip.com',
+            ticketNames: [
+                'cticket',
+                'uid'
+            ],
+            timeoutMs: 8_000
+        });
+        return cookie.ok;
+    } catch  {
+        return false;
+    }
+}
+export async function defaultProbe(opts) {
+    const ports = opts.ports ?? [
+        ...BRIDGE_PORTS
+    ];
+    for (const port of ports){
+        const ok = await new Promise((resolve)=>{
+            const req = request({
+                host: '127.0.0.1',
+                port,
+                path: '/status',
+                method: 'GET',
+                timeout: 2_000
+            }, (res)=>{
+                if (!res.statusCode || res.statusCode >= 400) {
+                    resolve(false);
+                    return;
+                }
+                let buf = '';
+                res.setEncoding('utf8');
+                res.on('data', (c)=>{
+                    buf += c;
+                });
+                res.on('end', ()=>{
+                    try {
+                        const payload = JSON.parse(buf);
+                        resolve(payload.extensionConnected === true);
+                    } catch  {
+                        resolve(false);
+                    }
+                });
+                res.on('error', ()=>resolve(false));
+            });
+            req.on('error', ()=>resolve(false));
+            req.on('timeout', ()=>{
+                req.destroy();
+                resolve(false);
+            });
+            req.end();
+        });
+        if (ok) return true;
+    }
+    return false;
+}
+export function startExtensionHealthWatch(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 120_000;
+    const intervalMs = opts.intervalMs ?? 5_000;
+    const maxRetries = opts.maxRetries ?? 1;
+    const businessProbe = opts.businessProbe ?? true;
+    const probe = opts.probe ?? (async ()=>{
+        const bridge = await import('./extension-bridge.js');
+        await bridge.getOrCreateSessionBridge({
+            keepBridge: opts.keepBridge === true
+        });
+        return combinedProbe(opts, businessProbe);
+    });
+    const now = opts.now ?? Date.now;
+    const state = {
+        cancelled: false,
+        readyCount: 0,
+        resolveOutcome: null
+    };
+    const finish = (outcome)=>{
+        if (state.resolveOutcome) {
+            const resolve = state.resolveOutcome;
+            state.resolveOutcome = null;
+            resolve(outcome);
+        }
+    };
+    const onAbort = ()=>{
+        state.cancelled = true;
+        finish({
+            ready: false,
+            reason: 'cancelled',
+            attempts: state.readyCount,
+            waitedMs: 0
+        });
+    };
+    opts.signal?.addEventListener('abort', onAbort, {
+        once: true
+    });
+    const waitReady = ()=>new Promise((resolve)=>{
+            if (state.cancelled) {
+                resolve({
+                    ready: false,
+                    reason: 'cancelled',
+                    attempts: 0,
+                    waitedMs: 0
+                });
+                return;
+            }
+            if (timeoutMs === 0) {
+                resolve({
+                    ready: false,
+                    reason: 'timeout',
+                    attempts: 0,
+                    waitedMs: 0
+                });
+                return;
+            }
+            state.resolveOutcome = resolve;
+            const deadline = now() + timeoutMs;
+            let attempts = 0;
+            let waitedMs = 0;
+            const tick = async ()=>{
+                if (state.cancelled || state.resolveOutcome === null) return;
+                attempts += 1;
+                try {
+                    const ready = await probe();
+                    if (ready && !state.cancelled) {
+                        state.readyCount += 1;
+                        waitedMs = timeoutMs - Math.max(0, deadline - now());
+                        if (state.readyCount <= maxRetries) {
+                            finish({
+                                ready: true,
+                                attempts,
+                                waitedMs: waitedMs > 0 ? waitedMs : 0
+                            });
+                            return;
+                        }
+                    }
+                } catch  {}
+                waitedMs = timeoutMs - Math.max(0, deadline - now());
+                if (now() >= deadline) {
+                    finish({
+                        ready: false,
+                        reason: 'timeout',
+                        attempts,
+                        waitedMs
+                    });
+                    return;
+                }
+                const remaining = deadline - now();
+                const delay = Math.min(intervalMs, Math.max(0, remaining));
+                if (delay <= 0) {
+                    finish({
+                        ready: false,
+                        reason: 'timeout',
+                        attempts,
+                        waitedMs
+                    });
+                    return;
+                }
+                setTimeout(tick, delay);
+            };
+            void tick();
+        });
+    return {
+        waitReady,
+        cancel: ()=>onAbort(),
+        get readyCount () {
+            return state.readyCount;
+        }
+    };
+}
+export async function withAutoRetryOnExtension(args) {
+    const first = await args.fetch();
+    if (!args.isExtensionNeeded(first)) {
+        return {
+            result: first,
+            retried: false,
+            attempts: 1,
+            outcome: {
+                ready: true,
+                attempts: 0,
+                waitedMs: 0
+            }
+        };
+    }
+    const watch = startExtensionHealthWatch(args.watch ?? {});
+    const outcome = await watch.waitReady();
+    if (!outcome.ready) {
+        return {
+            result: first,
+            retried: false,
+            attempts: 1,
+            outcome
+        };
+    }
+    const retriedResult = await (args.retry ?? args.fetch)();
+    return {
+        result: retriedResult,
+        retried: true,
+        attempts: 2,
+        outcome
+    };
+}
+export const HEALTH_WATCH_INTERVAL_FLOOR_MS = 1_000;
+export const HEALTH_WATCH_INTERVAL_CEIL_MS = EXTENSION_CONNECTED_WINDOW_MS - 1_000;
+
+
+//# sourceURL=ts/capabilities/session/health-watch.ts

package/dist/capabilities/session/read-guard.js

@@ -96,4 +96,4 @@ export async function attachReadGuardPuppeteer(browser, auditPath) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/read-guard.ts
+//# sourceURL=ts/capabilities/session/read-guard.ts

package/dist/capabilities/session/static-flight-golden.js

@@ -0,0 +1,137 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function parseGoldenSource(args) {
+    const raw = args.find((arg)=>arg.startsWith('--golden='))?.slice('--golden='.length) ?? 'manual';
+    if (raw === 'manual' || raw === 'flyai' || raw === 'static') return raw;
+    throw new Error(`不支持的 golden vendor: ${raw}`);
+}
+export function loadStaticFlightSnapshot(path = join(import.meta.dirname, '..', '..', 'data', 'sf-static-routes.json')) {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!isRecord(parsed) || parsed.schema_version !== 'sf-static-routes.v1') {
+        throw new Error(`invalid static snapshot schema_version: ${String(isRecord(parsed) ? parsed.schema_version : undefined)}`);
+    }
+    const source = parsed.source;
+    if (!isRecord(source) || ![
+        'name',
+        'url',
+        'revision',
+        'license',
+        'retrieved_at'
+    ].every((key)=>typeof source[key] === 'string') || !Array.isArray(source.limitations) || !source.limitations.every((item)=>typeof item === 'string')) {
+        throw new Error('invalid static snapshot source');
+    }
+    if (!Array.isArray(parsed.routes) || !parsed.routes.every(isStaticFlightRoute)) {
+        throw new Error('invalid static snapshot routes');
+    }
+    return parsed;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isStaticFlightRoute(value) {
+    if (!isRecord(value) || typeof value.query_id !== 'string' || typeof value.from_city !== 'string' || typeof value.to_city !== 'string' || value.route_kind !== 'direct' && value.route_kind !== 'transfer' || !Array.isArray(value.legs) || value.legs.length === 0) return false;
+    return value.legs.every((leg)=>isRecord(leg) && typeof leg.from_iata === 'string' && typeof leg.to_iata === 'string' && Array.isArray(leg.carrier_codes) && leg.carrier_codes.every((carrier)=>typeof carrier === 'string'));
+}
+function provenance(snapshot) {
+    return {
+        route_source: snapshot?.source.url ?? '',
+        route_revision: snapshot?.source.revision ?? '',
+        route_license: snapshot?.source.license ?? '',
+        band_source: 'sf-golden-manifest.json'
+    };
+}
+function formatWithOffset(timestampMs, offset) {
+    const sign = offset.startsWith('-') ? -1 : 1;
+    const [hours, minutes] = offset.slice(1).split(':').map(Number);
+    const offsetMinutes = sign * ((hours ?? 0) * 60 + (minutes ?? 0));
+    const local = new Date(timestampMs + offsetMinutes * 60_000).toISOString().slice(0, 19);
+    return `${local}${offset}`;
+}
+function buildSegments(query, route, manualSegment) {
+    if (route.route_kind === 'direct' && route.legs.length === 1) {
+        return [
+            {
+                from: query.from,
+                to: query.to,
+                departure_at: manualSegment.departure_at,
+                arrival_at: manualSegment.arrival_at,
+                transport_number: `${route.legs[0].carrier_codes[0]}-STATIC`
+            }
+        ];
+    }
+    if (route.route_kind !== 'transfer' || route.legs.length !== 2) return null;
+    const departureMs = Date.parse(manualSegment.departure_at);
+    const arrivalMs = Date.parse(manualSegment.arrival_at);
+    if (!Number.isFinite(departureMs) || !Number.isFinite(arrivalMs) || arrivalMs <= departureMs) return null;
+    const offset = manualSegment.departure_at.match(/([+-]\d{2}:\d{2})$/)?.[1] ?? '+08:00';
+    const totalMinutes = Math.floor((arrivalMs - departureMs) / 60_000);
+    if (totalMinutes < 90) return null;
+    const layoverMinutes = Math.min(60, Math.floor(totalMinutes / 3));
+    const travelMinutes = totalMinutes - layoverMinutes;
+    const firstTravelMinutes = Math.floor(travelMinutes / 2);
+    const secondDepartureMs = arrivalMs - (travelMinutes - firstTravelMinutes) * 60_000;
+    const middle = route.legs[0].to_iata;
+    return [
+        {
+            from: query.from,
+            to: middle,
+            departure_at: manualSegment.departure_at,
+            arrival_at: formatWithOffset(departureMs + firstTravelMinutes * 60_000, offset),
+            transport_number: `${route.legs[0].carrier_codes[0]}-STATIC`
+        },
+        {
+            from: middle,
+            to: query.to,
+            departure_at: formatWithOffset(secondDepartureMs, offset),
+            arrival_at: manualSegment.arrival_at,
+            transport_number: `${route.legs[1].carrier_codes[0]}-STATIC`
+        }
+    ];
+}
+export function resolveStaticGolden(input) {
+    const route = input.snapshot?.routes.find((candidate)=>candidate.query_id === input.query.id);
+    let fallbackReason;
+    if (input.snapshotError) {
+        fallbackReason = `static snapshot unavailable: ${input.snapshotError}`;
+    } else if (!route) {
+        fallbackReason = `static route missing for ${input.query.id}`;
+    } else if (route.from_city !== input.query.from || route.to_city !== input.query.to) {
+        fallbackReason = `static route mismatch for ${input.query.id}`;
+    } else if (route.legs.some((leg)=>leg.carrier_codes.length === 0)) {
+        fallbackReason = `static carrier coverage missing for ${input.query.id}`;
+    }
+    const manualSegment = input.manualRecord.route_segments[0];
+    const segments = !fallbackReason && route && manualSegment ? buildSegments(input.query, route, manualSegment) : null;
+    if (!fallbackReason && !segments) fallbackReason = `static route cannot form comparable record for ${input.query.id}`;
+    if (fallbackReason) {
+        input.warn?.(`[sf-live-benchmark] static vendor failed for ${input.query.id}: ${fallbackReason}; fallback=manual-golden`);
+        return {
+            requested_source: 'static',
+            effective_source: 'manual-golden',
+            record: input.manualRecord,
+            fallback_reason: fallbackReason,
+            estimated_fields: [],
+            provenance: provenance(input.snapshot)
+        };
+    }
+    return {
+        requested_source: 'static',
+        effective_source: 'static-openflights+manual-band',
+        record: {
+            ...input.manualRecord,
+            route_segments: segments,
+            journey_type: route.route_kind,
+            source: 'static-openflights+manual-band'
+        },
+        estimated_fields: [
+            'route_segments[].departure_at',
+            'route_segments[].arrival_at',
+            'route_segments[].transport_number',
+            'price'
+        ],
+        provenance: provenance(input.snapshot)
+    };
+}
+
+
+//# sourceURL=ts/capabilities/session/static-flight-golden.ts