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

package/dist/src/z3-shared.js

@@ -0,0 +1,284 @@
+/**
+ * Z3 WASM 运行时单例(README Known limitations「Z3 WASM race」的根治面)。
+ *
+ * 历史:engine/journey/unified 三模块各自 `init().Context('main')`:
+ *   - 一进程内并存 2-3 份独立 WASM 实例(内存放大;系统压力下 2GB 堆分配失败的 OOM 形态);
+ *   - 候选求解用 Promise.all 并发多候选共享同一 Context,z3-solver 的 async API
+ *     (Asyncify)不允许并发 unwind,交错即栈损坏 → `memory access out of bounds`
+ *     (run-all §1 重试止血的真因;rc.4 曾试统一单例但残留自建 Context 触发 mismatch 被回滚)。
+ *
+ * #227 补充:
+ *   - getZ3 必须在第一个 await 之前缓存 Promise,否则冷启动并发会创建多个 Context 对象;
+ *   - z3-solver 5.2.0 high-level FinalizationRegistry 的 cleanup 直接调用 low-level
+ *     `dec_ref`/`*_dec_ref`,不经过 GoTry `withZ3`。V8 判定对象不可达的时机保持不变;
+ *     GoTry 只在 Z3 会话活跃时把实际 native cleanup 推迟到会话 settle 后同步 drain,
+ *     防止 GC cleanup 与 check()/AST 构造并发碰同一 WASM heap。
+ *
+ * 现在的口径:三模块全部 import 本模块——单一 WASM 实例 + 单一 Context + 会话级
+ * 互斥(await chain 占链)。低层 cleanup 队列是局部包装,不替换全局 FinalizationRegistry,
+ * 不主动 free 仍可达对象;显式 release/GC finalizer 仍由 z3-solver 的所有权语义决定。
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+const MAX_DEFERRED_CLEANUPS = parseCleanupQueueLimit();
+const ASYNC_LOW_LEVEL_CALLS = new Set([
+    'simplify', 'simplify_ex', 'eval_smtlib2_string',
+    'tactic_apply', 'tactic_apply_ex',
+    'solver_check', 'solver_check_assumptions', 'solver_get_consequences', 'solver_cube',
+    'algebraic_roots', 'algebraic_eval',
+    'fixedpoint_query', 'fixedpoint_query_relations', 'fixedpoint_query_from_lvl',
+    'optimize_check', 'polynomial_subresultants',
+]);
+const nestedSession = new AsyncLocalStorage();
+const cleanupWrappedFunctions = new Set();
+const asyncWrappedFunctions = new Set();
+const nativeCleanupCalls = {};
+const deferredCleanupCalls = {};
+const drainedCleanupCalls = {};
+const deferredCleanups = [];
+const nativeIdleWaiters = [];
+let z3Promise = null;
+let z3SessionActive = false;
+let activeNativeCalls = 0;
+let z3Poisoned = null;
+let maxDeferredQueueDepth = 0;
+const lifecycleStats = {
+    initAttempts: 0,
+    contextsCreated: 0,
+    concurrentDecRefEnabled: 0,
+    sessionsStarted: 0,
+    sessionsSettled: 0,
+};
+/** 求解互斥链:后到会话排队等前一会话完全 settle(成败皆放行,不吞异常) */
+let chain = Promise.resolve();
+function incCounter(counters, name) {
+    counters[name] = (counters[name] ?? 0) + 1;
+}
+function parseCleanupQueueLimit() {
+    const raw = process.env.GOTRY_Z3_CLEANUP_QUEUE_LIMIT ?? '2000000';
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0)
+        throw new Error(`GOTRY_Z3_CLEANUP_QUEUE_LIMIT must be a positive integer: ${raw}`);
+    return value;
+}
+function poisonZ3(error, fatalNative = false) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    if (!z3Poisoned)
+        z3Poisoned = { error: err, fatalNative };
+    else
+        z3Poisoned.fatalNative = z3Poisoned.fatalNative || fatalNative;
+    return err;
+}
+function poisonMessage() {
+    return z3Poisoned ? z3Poisoned.error.message : null;
+}
+function hasFatalNativePoison() {
+    return z3Poisoned ? z3Poisoned.fatalNative : false;
+}
+function callNativeCleanup(name, invoke, fromDrain) {
+    try {
+        invoke();
+        if (fromDrain)
+            incCounter(drainedCleanupCalls, name);
+        return null;
+    }
+    catch (error) {
+        const err = poisonZ3(error, isFatalZ3Error(error));
+        // This wrapper can be reached from z3-solver's FinalizationRegistry cleanup.
+        // Never throw from the cleanup call-site; surface the poison at the next controlled withZ3 entry.
+        return err;
+    }
+}
+function deferNativeCleanup(cleanup) {
+    deferredCleanups.push(cleanup);
+    incCounter(deferredCleanupCalls, cleanup.name);
+    if (deferredCleanups.length > maxDeferredQueueDepth)
+        maxDeferredQueueDepth = deferredCleanups.length;
+    if (deferredCleanups.length > MAX_DEFERRED_CLEANUPS) {
+        poisonZ3(new Error(`Z3 cleanup queue overflow (${deferredCleanups.length}/${MAX_DEFERRED_CLEANUPS})`), false);
+    }
+}
+function beginNativeCall() {
+    activeNativeCalls += 1;
+}
+function finishNativeCall() {
+    activeNativeCalls -= 1;
+    if (activeNativeCalls < 0) {
+        activeNativeCalls = 0;
+        poisonZ3(new Error('Z3 native async call counter underflow'));
+    }
+    if (activeNativeCalls === 0) {
+        for (const resolve of nativeIdleWaiters.splice(0))
+            resolve();
+        if (!z3SessionActive && !hasFatalNativePoison())
+            drainDeferredCleanups();
+    }
+}
+async function waitForNativeIdle() {
+    if (activeNativeCalls === 0)
+        return;
+    await new Promise(resolve => nativeIdleWaiters.push(resolve));
+}
+function trackNativePromise(name, promise) {
+    return promise.then(value => value, error => {
+        if (isFatalZ3Error(error))
+            poisonZ3(error, true);
+        throw error;
+    }).finally(() => finishNativeCall());
+}
+function drainDeferredCleanups() {
+    let firstError = null;
+    while (deferredCleanups.length > 0) {
+        const cleanup = deferredCleanups.pop();
+        const err = callNativeCleanup(cleanup.name, cleanup.invoke, true);
+        if (!err)
+            continue;
+        if (!firstError)
+            firstError = err;
+        if (hasFatalNativePoison()) {
+            deferredCleanups.push(cleanup);
+            break;
+        }
+    }
+    return firstError;
+}
+function installZ3RuntimeGuards(Z3) {
+    for (const name of Object.keys(Z3)) {
+        if (ASYNC_LOW_LEVEL_CALLS.has(name)) {
+            const original = Z3[name];
+            if (typeof original === 'function' && !original.__gotryNativeAsyncWrapped) {
+                const wrapped = (...args) => {
+                    beginNativeCall();
+                    let result;
+                    try {
+                        result = original(...args);
+                    }
+                    catch (error) {
+                        if (isFatalZ3Error(error))
+                            poisonZ3(error, true);
+                        finishNativeCall();
+                        throw error;
+                    }
+                    if (result instanceof Promise)
+                        return trackNativePromise(name, result);
+                    finishNativeCall();
+                    return result;
+                };
+                Object.defineProperty(wrapped, '__gotryNativeAsyncWrapped', { value: true });
+                Z3[name] = wrapped;
+                asyncWrappedFunctions.add(name);
+            }
+        }
+        if (name !== 'dec_ref' && !name.endsWith('_dec_ref'))
+            continue;
+        const original = Z3[name];
+        if (typeof original !== 'function' || original.__gotryCleanupQueueWrapped)
+            continue;
+        const wrapped = (...args) => {
+            incCounter(nativeCleanupCalls, name);
+            const invoke = () => original(...args);
+            if (hasFatalNativePoison() || z3SessionActive || activeNativeCalls > 0) {
+                deferNativeCleanup({ name, args, invoke });
+                return undefined;
+            }
+            return callNativeCleanup(name, invoke, false);
+        };
+        Object.defineProperty(wrapped, '__gotryCleanupQueueWrapped', { value: true });
+        Z3[name] = wrapped;
+        cleanupWrappedFunctions.add(name);
+    }
+}
+/** Initialize one shared Context and install the local low-level cleanup queue. */
+export async function initZ3Context(loadInit) {
+    lifecycleStats.initAttempts += 1;
+    const api = await loadInit();
+    installZ3RuntimeGuards(api.Z3);
+    const ctx = api.Context('main');
+    lifecycleStats.contextsCreated += 1;
+    if (typeof api.Z3.enable_concurrent_dec_ref !== 'function') {
+        throw new Error('z3-solver low-level API missing enable_concurrent_dec_ref; refusing unsafe Z3 context');
+    }
+    api.Z3.enable_concurrent_dec_ref(ctx.ptr);
+    lifecycleStats.concurrentDecRefEnabled += 1;
+    return ctx;
+}
+export async function getZ3() {
+    // 延迟到首次实际求解才加载:避免 dsh 加载 GoTry 模块时启动 WASM worker。
+    // Promise 必须在第一个 await 之前写入缓存,防冷启动并发创建多 Context。
+    if (!z3Promise) {
+        z3Promise = (async () => {
+            const { init } = await import('z3-solver');
+            return initZ3Context(init);
+        })().catch(error => {
+            z3Promise = null;
+            throw error;
+        });
+    }
+    return z3Promise;
+}
+/** Z3 求解会话互斥门:全程独占 WASM 实例,防 Asyncify 并发 unwind(栈损坏根因)。 */
+export async function withZ3(label, session) {
+    const outer = nestedSession.getStore();
+    if (outer)
+        throw new Error(`nested withZ3 is forbidden (${outer} -> ${label})`);
+    const z3 = await getZ3();
+    const turn = chain.then(() => nestedSession.run(label, () => runZ3Session(label, z3, session)));
+    // 链推进到本会话 settlement(吞掉的只是链上对前序错误的转发,异常仍从本会话返回值抛出)
+    chain = turn.then(() => undefined, () => undefined);
+    return turn;
+}
+async function runZ3Session(label, z3, session) {
+    if (poisonMessage())
+        throw new Error(`Z3 context is poisoned; refusing new solve (${poisonMessage()})`);
+    lifecycleStats.sessionsStarted += 1;
+    z3SessionActive = true;
+    let value;
+    let sessionFailed = false;
+    let sessionError;
+    let cleanupError = null;
+    try {
+        value = await session(z3);
+    }
+    catch (error) {
+        sessionFailed = true;
+        sessionError = error;
+    }
+    finally {
+        await waitForNativeIdle();
+        if (sessionFailed && isFatalZ3Error(sessionError))
+            poisonZ3(sessionError, true);
+        z3SessionActive = false;
+        cleanupError = hasFatalNativePoison() ? null : drainDeferredCleanups();
+        lifecycleStats.sessionsSettled += 1;
+    }
+    if (sessionFailed) {
+        if (cleanupError && typeof sessionError === 'object' && sessionError !== null) {
+            ;
+            sessionError.z3CleanupError = cleanupError;
+        }
+        throw sessionError;
+    }
+    if (cleanupError)
+        throw cleanupError;
+    if (poisonMessage())
+        throw new Error(`Z3 context is poisoned after ${label}; refusing result reuse (${poisonMessage()})`);
+    return value;
+}
+function isFatalZ3Error(error) {
+    const text = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    return /memory access out of bounds|corrupted (?:its )?heap memory|RuntimeError: Aborted|abort\(Runtime error/i.test(text);
+}
+export function getZ3LifecycleStats() {
+    return {
+        ...lifecycleStats,
+        cleanupWrappedFunctions: [...cleanupWrappedFunctions].sort(),
+        asyncWrappedFunctions: [...asyncWrappedFunctions].sort(),
+        cleanupQueueLimit: MAX_DEFERRED_CLEANUPS,
+        activeNativeCalls,
+        nativeCleanupCalls: { ...nativeCleanupCalls },
+        deferredCleanupCalls: { ...deferredCleanupCalls },
+        drainedCleanupCalls: { ...drainedCleanupCalls },
+        maxDeferredQueueDepth,
+        currentDeferredQueueDepth: deferredCleanups.length,
+        poisoned: poisonMessage(),
+    };
+}

package/extension/README.md

@@ -0,0 +1,21 @@
+[English](README.md) | [简体中文](README.zh-CN.md)
+
+# Stai browser extension
+
+Stai (formerly GoTry Session Bridge) connects supported travel-search pages to GoTry. The Chrome Web Store and unpacked builds have different extension IDs but use the same bridge contract.
+
+## What it does
+
+- Observes matching search responses on supported Ctrip flight/hotel, 12306 rail and Dida supplier-portal pages. It selects specified login-cookie **names**, not their values.
+- Sends search results and status to the local GoTry bridge in desktop use. An authenticated HotelByte employee portal can instead provide a short-lived ticket for its backend bridge, in which case search data can leave the device.
+- When that portal supplies authorized one-time Dida login credentials, the extension handles them in memory, opens the allowlisted login page, fills and submits the form. It can also operate Dida search controls. It does not persist credentials in extension storage or perform bookings or payments.
+
+See the [privacy policy](https://github.com/Danceiny/gotry/blob/main/docs/ops/extension-privacy.md) for the current data and destination disclosure.
+
+## Install
+
+1. [Chrome Web Store](https://chromewebstore.google.com/detail/gotry-session-bridge/oeajpiccmonococjcegddlooeeohlbgd): one-click install and automatic store updates. Check the **version shown on the listing** before relying on Dida/HotelByte capabilities; the store can lag source and GitHub builds while an update is under review.
+2. GitHub Releases: run `npx @danceiny/gotry setup --extension-from=github`, or download and verify the versioned `ext-*` release's `gotry-session-bridge.tar.gz`, then load the extracted directory from `chrome://extensions` with Developer mode enabled.
+3. npm package fallback: run `npx @danceiny/gotry setup` and load `~/.gotry/extension` in `chrome://extensions`. The npm package may lag the source and GitHub extension release.
+
+The store ID is `oeajpiccmonococjcegddlooeeohlbgd`; the unpacked ID is `olpgkofjhhiiiahdkkbcninhjmegghfe`. For desktop use, GoTry's local bridge listens on `127.0.0.1` ports 8791–8795.

package/extension/README.zh-CN.md

@@ -0,0 +1,21 @@
+[English](README.md) | [简体中文](README.zh-CN.md)
+
+# Stai 浏览器扩展
+
+Stai（原名 GoTry Session Bridge）将已支持的旅行检索页面连接至 GoTry。商店版与本地加载版的扩展 ID 不同，但使用相同的桥接合同。
+
+## 功能
+
+- 观察已支持的携程机票及酒店、12306 火车、Dida 供应商门户页面的匹配检索回包。扩展只选取指定登录 cookie 的**名称**，不转发 cookie 值。
+- 桌面形态将检索结果及状态发送到本机 GoTry 桥。已认证的 HotelByte 员工门户也可提供短期票据，接入其后端桥；此时检索数据可能离开设备。
+- 门户提供获准的一次性 Dida 登录凭据时，扩展在内存中处理，打开白名单内的登录页，填写并提交表单。扩展还可操作 Dida 检索控件。扩展不在持久化存储中保存凭据，也不执行预订或付款。
+
+数据和去向的现行说明见[隐私政策](https://github.com/Danceiny/gotry/blob/main/docs/ops/extension-privacy.zh-CN.md)。
+
+## 安装
+
+1. [Chrome Web Store](https://chromewebstore.google.com/detail/gotry-session-bridge/oeajpiccmonococjcegddlooeeohlbgd)：一键安装，商店自动更新。依赖 Dida／HotelByte 能力前，请核对**商店页显示的版本**；审核期间商店版可能晚于源码与 GitHub 包。
+2. GitHub Releases：运行 `npx @danceiny/gotry setup --extension-from=github`；或下载并校验对应 `ext-*` 标签的 `gotry-session-bridge.tar.gz`，解压后在 `chrome://extensions` 开启开发者模式并加载目录。
+3. npm 包内兜底：运行 `npx @danceiny/gotry setup`，再到 `chrome://extensions` 加载 `~/.gotry/extension`。npm 包可能晚于源码和 GitHub 扩展 Release。
+
+商店版 ID 为 `oeajpiccmonococjcegddlooeeohlbgd`；本地加载版 ID 为 `olpgkofjhhiiiahdkkbcninhjmegghfe`。桌面形态的 GoTry 本机桥监听 `127.0.0.1` 的 8791—8795 端口。