@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/src/server/workflows/WorkflowContract.js

@@ -7,6 +7,7 @@ export class WorkflowNodeBuilder {
 export class ToolNodeBuilder extends WorkflowNodeBuilder {
     toolName;
     _input;
+    _inputFrom;
     _retry;
     _timeoutMs;
     constructor(id, toolName) {
@@ -17,6 +18,10 @@ export class ToolNodeBuilder extends WorkflowNodeBuilder {
         this._input = input;
         return this;
     }
+    inputFrom(mapping) {
+        this._inputFrom = mapping;
+        return this;
+    }
     retry(policy) {
         this._retry = policy;
         return this;
@@ -31,6 +36,7 @@ export class ToolNodeBuilder extends WorkflowNodeBuilder {
             id: this.id,
             toolName: this.toolName,
             input: this._input,
+            inputFrom: this._inputFrom,
             retry: this._retry,
             timeoutMs: this._timeoutMs,
         };
@@ -70,6 +76,13 @@ export class SequenceNodeBuilder extends WorkflowNodeBuilder {
         this._steps.push(builder);
         return this;
     }
+    fallback(id, config) {
+        const builder = new FallbackNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
     build() {
         return {
             kind: 'sequence',
@@ -114,6 +127,13 @@ export class ParallelNodeBuilder extends WorkflowNodeBuilder {
         this._steps.push(builder);
         return this;
     }
+    fallback(id, config) {
+        const builder = new FallbackNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
     maxConcurrency(concurrency) {
         this._maxConcurrency = concurrency;
         return this;
@@ -167,6 +187,32 @@ export class BranchNodeBuilder extends WorkflowNodeBuilder {
         };
     }
 }
+export class FallbackNodeBuilder extends WorkflowNodeBuilder {
+    _primary;
+    _fallback;
+    primary(nodeBuilder) {
+        this._primary = nodeBuilder;
+        return this;
+    }
+    fallback(nodeBuilder) {
+        this._fallback = nodeBuilder;
+        return this;
+    }
+    build() {
+        if (!this._primary) {
+            throw new Error(`FallbackNode '${this.id}' requires a primary step`);
+        }
+        if (!this._fallback) {
+            throw new Error(`FallbackNode '${this.id}' requires a fallback step`);
+        }
+        return {
+            kind: 'fallback',
+            id: this.id,
+            primary: this._primary.build(),
+            fallback: this._fallback.build(),
+        };
+    }
+}
 export class WorkflowBuilder {
     _id;
     _displayName;
@@ -174,6 +220,7 @@ export class WorkflowBuilder {
     _tags;
     _timeoutMs;
     _defaultMaxConcurrency;
+    _route;
     _buildFn;
     _onStart;
     _onFinish;
@@ -198,6 +245,10 @@ export class WorkflowBuilder {
         this._defaultMaxConcurrency = max;
         return this;
     }
+    route(route) {
+        this._route = route;
+        return this;
+    }
     buildGraph(fn) {
         this._buildFn = (ctx) => fn(ctx).build();
         return this;
@@ -226,6 +277,7 @@ export class WorkflowBuilder {
             tags: this._tags,
             timeoutMs: this._timeoutMs,
             defaultMaxConcurrency: this._defaultMaxConcurrency,
+            route: this._route,
             build: this._buildFn,
             onStart: this._onStart,
             onFinish: this._onFinish,

package/dist/src/server/workflows/WorkflowEngine.d.ts

@@ -16,6 +16,7 @@ interface WorkflowSpan {
 export interface ExecuteWorkflowOptions {
     profile?: string;
     config?: JsonRecord;
+    preflightMode?: 'warn' | 'strict' | 'skip';
     nodeInputOverrides?: Record<string, Record<string, unknown>>;
     timeoutMs?: number;
 }

package/dist/src/server/workflows/WorkflowEngine.js

@@ -1,4 +1,55 @@
 import { randomUUID } from 'node:crypto';
+import { getEffectivePrerequisites } from '../ToolRouter.policy.js';
+import { getRoutingState } from '../ToolRouter.probe.js';
+class WorkflowDataBus {
+    store = new Map();
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    getValueAtPath(key, path) {
+        const value = this.store.get(key);
+        if (!value || typeof value !== 'object') {
+            return value;
+        }
+        const payload = parseToolPayload(value);
+        const obj = payload || value;
+        return path.split('.').reduce((current, segment) => {
+            if (current && typeof current === 'object') {
+                const arrayMatch = segment.match(/^(\d+)$/);
+                if (arrayMatch && Array.isArray(current)) {
+                    return current[Number(arrayMatch[1])];
+                }
+                return current[segment];
+            }
+            return undefined;
+        }, obj);
+    }
+    resolve(template) {
+        const match = template.match(/^\$\{(.+)\}$/);
+        if (!match || !match[1]) {
+            return template;
+        }
+        const ref = match[1];
+        const dotIndex = ref.indexOf('.');
+        if (dotIndex === -1) {
+            return this.store.get(ref);
+        }
+        const stepId = ref.slice(0, dotIndex);
+        const fieldPath = ref.slice(dotIndex + 1);
+        return this.getValueAtPath(stepId, fieldPath);
+    }
+}
+class PreflightError extends Error {
+    warnings;
+    constructor(warnings) {
+        super(`Workflow preflight failed with ${warnings.length} unsatisfied prerequisite(s)`);
+        this.warnings = warnings;
+        this.name = 'PreflightError';
+    }
+}
 function extractConfigValue(config, path, fallback) {
     const segments = path.split('.').filter(Boolean);
     let current = config;
@@ -77,9 +128,49 @@ function collectSuccessStats(value) {
     }
     return { success: 0, failure: 0 };
 }
-async function runToolNode(ctx, node, overrides) {
+function resolveInputFrom(mapping, dataBus) {
+    const resolved = {};
+    for (const [targetKey, sourceRef] of Object.entries(mapping)) {
+        const template = sourceRef.startsWith('${') ? sourceRef : `\${${sourceRef}}`;
+        resolved[targetKey] = dataBus.resolve(template);
+    }
+    return resolved;
+}
+function resolveInputValues(input, dataBus) {
+    if (!input)
+        return {};
+    const resolved = {};
+    for (const [key, value] of Object.entries(input)) {
+        resolved[key] = resolveValue(value, dataBus);
+    }
+    return resolved;
+}
+function resolveValue(value, dataBus) {
+    if (typeof value === 'string') {
+        return dataBus.resolve(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveValue(item, dataBus));
+    }
+    if (value && typeof value === 'object') {
+        const resolved = {};
+        for (const [k, v] of Object.entries(value)) {
+            resolved[k] = resolveValue(v, dataBus);
+        }
+        return resolved;
+    }
+    return value;
+}
+async function runToolNode(ctx, node, overrides, executionContext) {
+    const fromResolved = node.inputFrom
+        ? resolveInputFrom(node.inputFrom, executionContext.dataBus)
+        : {};
+    const fromInputValues = node.input
+        ? resolveInputValues(node.input, executionContext.dataBus)
+        : {};
     const mergedInput = {
-        ...node.input,
+        ...fromInputValues,
+        ...fromResolved,
         ...overrides?.[node.id],
     };
     const runAttempt = async () => {
@@ -88,6 +179,7 @@ async function runToolNode(ctx, node, overrides) {
         if (failure) {
             throw new Error(failure);
         }
+        executionContext.dataBus.set(node.id, response);
         return response;
     };
     const retry = node.retry;
@@ -113,7 +205,7 @@ async function runToolNode(ctx, node, overrides) {
 }
 async function runParallelNode(ctx, node, executionContext, options) {
     const concurrency = Math.max(1, node.maxConcurrency ?? 4);
-    const results = new Array(node.steps.length);
+    const results = Array.from({ length: node.steps.length });
     let nextIndex = 0;
     let stopped = false;
     const worker = async () => {
@@ -145,6 +237,38 @@ async function runParallelNode(ctx, node, executionContext, options) {
     await Promise.all(Array.from({ length: Math.min(concurrency, node.steps.length) }, () => worker()));
     return results;
 }
+function getWorkflowVariable(stepResults, keyPath) {
+    if (stepResults.has(keyPath)) {
+        return stepResults.get(keyPath);
+    }
+    const segments = keyPath.split('.');
+    const stepId = segments[0];
+    const fieldSegments = segments.slice(1);
+    if (!stepId || !stepResults.has(stepId)) {
+        return undefined;
+    }
+    let current = stepResults.get(stepId);
+    if (current && typeof current === 'object') {
+        const payload = parseToolPayload(current);
+        if (payload) {
+            current = payload;
+        }
+    }
+    for (const segment of fieldSegments) {
+        if (current && typeof current === 'object') {
+            const arrayMatch = segment.match(/^(\d+)$/);
+            if (arrayMatch && Array.isArray(current)) {
+                current = current[Number(arrayMatch[1])];
+                continue;
+            }
+            current = current[segment];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
 async function evaluatePredicate(node, ctx) {
     if (node.predicateFn) {
         return await node.predicateFn(ctx);
@@ -170,14 +294,72 @@ async function evaluatePredicate(node, ctx) {
             return false;
         return aggregate.success / total >= threshold / 100;
     }
+    const equalsMatch = node.predicateId.match(/^variable_equals_(.+?)_(.+)$/);
+    if (equalsMatch && equalsMatch[1] && equalsMatch[2]) {
+        const keyPath = equalsMatch[1];
+        const expectedValue = equalsMatch[2];
+        const actualValue = getWorkflowVariable(ctx.stepResults, keyPath);
+        return deepEquals(actualValue, expectedValue);
+    }
+    const containsMatch = node.predicateId.match(/^variable_contains_(.+?)_(.+)$/);
+    if (containsMatch && containsMatch[1] && containsMatch[2]) {
+        const keyPath = containsMatch[1];
+        const substring = containsMatch[2];
+        const value = getWorkflowVariable(ctx.stepResults, keyPath);
+        if (typeof value !== 'string' && !Array.isArray(value)) {
+            return false;
+        }
+        return String(value).includes(substring);
+    }
+    const matchesMatch = node.predicateId.match(/^variable_matches_(.+?)_(.+)$/);
+    if (matchesMatch && matchesMatch[1] && matchesMatch[2]) {
+        const keyPath = matchesMatch[1];
+        const pattern = matchesMatch[2];
+        const value = getWorkflowVariable(ctx.stepResults, keyPath);
+        if (typeof value !== 'string') {
+            return false;
+        }
+        try {
+            const regex = new RegExp(pattern);
+            return regex.test(value);
+        }
+        catch {
+            return false;
+        }
+    }
     throw new Error(`Unknown workflow predicateId "${node.predicateId}"`);
 }
+function deepEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (typeof a !== typeof b) {
+        return false;
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        if (Array.isArray(a) !== Array.isArray(b)) {
+            return false;
+        }
+        if (Array.isArray(a)) {
+            const arrA = a;
+            const arrB = b;
+            return arrA.length === arrB.length && arrA.every((v, i) => deepEquals(v, arrB[i]));
+        }
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) {
+            return false;
+        }
+        return keysA.every((key) => deepEquals(a[key], b[key]));
+    }
+    return false;
+}
 async function executeNode(ctx, node, executionContext, options) {
     executionContext.emitSpan('workflow.node.start', { nodeId: node.id, kind: node.kind });
     let result;
     switch (node.kind) {
         case 'tool':
-            result = await runToolNode(ctx, node, options.nodeInputOverrides);
+            result = await runToolNode(ctx, node, options.nodeInputOverrides, executionContext);
             break;
         case 'sequence': {
             const sequenceNode = node;
@@ -203,6 +385,22 @@ async function executeNode(ctx, node, executionContext, options) {
             }
             break;
         }
+        case 'fallback': {
+            const fallbackNode = node;
+            try {
+                result = await executeNode(ctx, fallbackNode.primary, executionContext, options);
+            }
+            catch (error) {
+                executionContext.emitSpan('workflow.node.fallback', {
+                    nodeId: fallbackNode.id,
+                    primaryNodeId: fallbackNode.primary.id,
+                    fallbackNodeId: fallbackNode.fallback.id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                result = await executeNode(ctx, fallbackNode.fallback, executionContext, options);
+            }
+            break;
+        }
         default:
             throw new Error(`Unsupported workflow node kind: ${node.kind}`);
     }
@@ -210,6 +408,59 @@ async function executeNode(ctx, node, executionContext, options) {
     executionContext.emitSpan('workflow.node.finish', { nodeId: node.id, kind: node.kind });
     return result;
 }
+function collectToolNodes(node) {
+    switch (node.kind) {
+        case 'tool':
+            return [node];
+        case 'sequence':
+        case 'parallel':
+            return node.steps.flatMap((step) => collectToolNodes(step));
+        case 'branch':
+            return [
+                ...collectToolNodes(node.whenTrue),
+                ...(node.whenFalse ? collectToolNodes(node.whenFalse) : []),
+            ];
+        case 'fallback': {
+            const fallbackNode = node;
+            return [
+                ...collectToolNodes(fallbackNode.primary),
+                ...collectToolNodes(fallbackNode.fallback),
+            ];
+        }
+        default:
+            return [];
+    }
+}
+function getEvidenceState(ctx) {
+    try {
+        const evidenceGraph = ctx.getDomainInstance('evidenceGraph');
+        return evidenceGraph
+            ? { hasGraph: true, nodeCount: evidenceGraph.nodeCount, edgeCount: evidenceGraph.edgeCount }
+            : { hasGraph: false, nodeCount: 0, edgeCount: 0 };
+    }
+    catch {
+        return { hasGraph: false, nodeCount: 0, edgeCount: 0 };
+    }
+}
+function collectUnsatisfiedPrerequisites(graph, routingState) {
+    const prerequisites = getEffectivePrerequisites();
+    const warnings = [];
+    for (const toolNode of collectToolNodes(graph)) {
+        const toolPrerequisites = prerequisites[toolNode.toolName] ?? [];
+        for (const prerequisite of toolPrerequisites) {
+            if (prerequisite.check(routingState)) {
+                continue;
+            }
+            warnings.push({
+                nodeId: toolNode.id,
+                toolName: toolNode.toolName,
+                condition: prerequisite.condition,
+                fix: prerequisite.fix,
+            });
+        }
+    }
+    return warnings;
+}
 export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     const runId = randomUUID();
     const profile = options.profile ?? String(ctx.baseTier ?? 'workflow');
@@ -218,6 +469,7 @@ export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     const metrics = [];
     const spans = [];
     const stepResults = new Map();
+    const dataBus = new WorkflowDataBus();
     const mergedConfig = options.config
         ? { ...ctx.config, ...options.config }
         : ctx.config;
@@ -225,6 +477,7 @@ export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
         workflowRunId: runId,
         profile,
         stepResults,
+        dataBus,
         invokeTool(toolName, args) {
             return ctx.executeToolWithTracking(toolName, args);
         },
@@ -241,8 +494,65 @@ export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     try {
         await workflow.onStart?.(executionContext);
         const graph = workflow.build(executionContext);
+        const preflightMode = options.preflightMode ?? 'warn';
+        let preflightWarnings = [];
+        if (preflightMode === 'skip') {
+            executionContext.emitSpan('workflow.preflight', {
+                mode: preflightMode,
+                skipped: true,
+                evidenceState: getEvidenceState(ctx),
+                warningCount: 0,
+            });
+        }
+        else {
+            try {
+                const routingState = await getRoutingState(ctx);
+                const evidenceState = getEvidenceState(ctx);
+                preflightWarnings = collectUnsatisfiedPrerequisites(graph, routingState);
+                executionContext.emitSpan('workflow.preflight', {
+                    mode: preflightMode,
+                    routingState,
+                    evidenceState,
+                    warningCount: preflightWarnings.length,
+                    warnings: preflightWarnings,
+                });
+                if (preflightMode === 'strict' && preflightWarnings.length > 0) {
+                    throw new PreflightError(preflightWarnings);
+                }
+            }
+            catch (error) {
+                if (error instanceof PreflightError) {
+                    throw error;
+                }
+                executionContext.emitSpan('workflow.preflight', {
+                    mode: preflightMode,
+                    warningCount: 0,
+                    skipped: true,
+                    error: error instanceof Error ? error.message : String(error),
+                    evidenceState: getEvidenceState(ctx),
+                });
+            }
+        }
         const result = await withTimeout(executeNode(ctx, graph, executionContext, options), options.timeoutMs ?? workflow.timeoutMs ?? 0, `Workflow "${workflow.id}"`);
         await workflow.onFinish?.(executionContext, result);
+        try {
+            const evidenceGraph = typeof ctx.getDomainInstance === 'function'
+                ? ctx.getDomainInstance('evidenceGraph')
+                : undefined;
+            if (evidenceGraph && evidenceGraph.nodeCount > 0) {
+                stepResults.set('__evidenceSnapshot', evidenceGraph.exportJson());
+                executionContext.emitSpan('workflow.evidence.auto-export', {
+                    nodeCount: evidenceGraph.nodeCount,
+                    edgeCount: evidenceGraph.edgeCount,
+                });
+            }
+        }
+        catch (exportError) {
+            executionContext.emitSpan('workflow.evidence.auto-export', {
+                skipped: true,
+                error: exportError instanceof Error ? exportError.message : String(exportError),
+            });
+        }
         return {
             workflowId: workflow.id,
             displayName: workflow.displayName,

package/dist/src/types/config.d.ts

@@ -1,24 +1,10 @@
 export interface Config {
-    llm: LLMConfig;
     puppeteer: PuppeteerConfig;
     mcp: MCPConfig;
     cache: CacheConfig;
     performance: PerformanceConfig;
     search: SearchConfig;
 }
-export interface LLMConfig {
-    provider: 'openai' | 'anthropic';
-    openai?: {
-        apiKey: string;
-        model: string;
-        baseURL?: string;
-    };
-    anthropic?: {
-        apiKey: string;
-        model: string;
-        baseURL?: string;
-    };
-}
 export interface PuppeteerConfig {
     headless: boolean;
     timeout: number;

package/dist/src/types/deobfuscator.d.ts

@@ -6,7 +6,6 @@ export interface Transformation {
 }
 export interface DeobfuscateOptions {
     code: string;
-    llm?: 'gpt-4' | 'claude';
     aggressive?: boolean;
     preserveLogic?: boolean;
     renameVariables?: boolean;
@@ -61,4 +60,5 @@ export interface DeobfuscateResult {
     warnings?: string[];
     engine?: 'legacy' | 'webcrack' | 'hybrid';
     webcrackApplied?: boolean;
+    cached?: boolean;
 }

package/dist/src/types/index.d.ts

@@ -1,5 +1,5 @@
 export type { CodeLocation, Result } from './common.js';
-export type { Config, LLMConfig, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, SearchConfig, SearchQueryCategoryProfileConfig, SearchCjkQueryAliasConfig, SearchIntentToolBoostRuleConfig, } from './config.js';
+export type { Config, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, SearchConfig, SearchQueryCategoryProfileConfig, SearchCjkQueryAliasConfig, SearchIntentToolBoostRuleConfig, } from './config.js';
 export type { BrowserContext } from './browser.js';
 export type { CollectCodeOptions, CodeFile, CollectCodeResult, DependencyGraph, DependencyNode, DependencyEdge, } from './collector.js';
 export type { ObfuscationType, Transformation, DeobfuscateOptions, DeobfuscateResult, DeobfuscateMappingRule, DeobfuscateSavedArtifact, DeobfuscateBundleModuleSummary, DeobfuscateBundleSummary, } from './deobfuscator.js';

package/dist/src/utils/DetailedDataManager.js

@@ -51,6 +51,8 @@ export class DetailedDataManager {
         return Object(value)[key];
     }
     smartHandle(data, threshold = DETAILED_DATA_SMART_THRESHOLD_BYTES) {
+        if (data === null || data === undefined || typeof data !== 'object')
+            return data;
         const { json: jsonStr, size } = this.serializeWithMemo(data);
         if (size <= threshold) {
             return data;

package/dist/src/utils/RingBuffer.js

@@ -6,7 +6,7 @@ export class RingBuffer {
     count = 0;
     constructor(capacity) {
         this.capacity = capacity;
-        this.buf = new Array(capacity);
+        this.buf = Array.from({ length: capacity });
     }
     get length() {
         return this.count;
@@ -37,7 +37,7 @@ export class RingBuffer {
         return item;
     }
     clear() {
-        this.buf = new Array(Math.min(64, this.capacity));
+        this.buf = Array.from({ length: Math.min(64, this.capacity) });
         this.head = 0;
         this.tail = 0;
         this.count = 0;
@@ -48,14 +48,14 @@ export class RingBuffer {
         }
     }
     toArray() {
-        const result = new Array(this.count);
+        const result = Array.from({ length: this.count });
         for (let i = 0; i < this.count; i++) {
             result[i] = this.buf[(this.head + i) % this.buf.length];
         }
         return result;
     }
     map(fn) {
-        const result = new Array(this.count);
+        const result = Array.from({ length: this.count });
         for (let i = 0; i < this.count; i++) {
             result[i] = fn(this.buf[(this.head + i) % this.buf.length], i);
         }
@@ -63,7 +63,7 @@ export class RingBuffer {
     }
     grow() {
         const newSize = Math.min(this.buf.length * 2, this.capacity);
-        const newBuf = new Array(newSize);
+        const newBuf = Array.from({ length: newSize });
         for (let i = 0; i < this.count; i++) {
             newBuf[i] = this.buf[(this.head + i) % this.buf.length];
         }

package/dist/src/utils/TokenBudgetManager.js

@@ -257,7 +257,7 @@ export class TokenBudgetManager {
             tokens,
             percentage: Math.round((tokens / this.currentUsage) * 100),
         }))
-            .sort((a, b) => b.tokens - a.tokens)
+            .toSorted((a, b) => b.tokens - a.tokens)
             .slice(0, 10);
         const suggestions = this.generateSuggestions(topTools);
         const recentCalls = this.toolCallHistory.slice(-20);

package/dist/src/utils/UnifiedCacheManager.js

@@ -125,7 +125,7 @@ export class UnifiedCacheManager {
     async cleanupLargeItems() {
         logger.info('Cleaning up large caches...');
         const stats = await this.getGlobalStats();
-        const sortedCaches = stats.caches.sort((a, b) => b.size - a.size);
+        const sortedCaches = stats.caches.toSorted((a, b) => b.size - a.size);
         for (const cacheStats of sortedCaches.slice(0, 2)) {
             const cache = this.caches.get(cacheStats.name);
             if (cache?.clear) {

package/dist/src/utils/artifactRetention.js

@@ -38,7 +38,7 @@ export async function cleanupArtifacts(options) {
     if (cutoff > 0) {
         const agedOut = remaining
             .filter((entry) => entry.mtimeMs < cutoff)
-            .sort((a, b) => a.mtimeMs - b.mtimeMs);
+            .toSorted((a, b) => a.mtimeMs - b.mtimeMs);
         if (agedOut.length > 0) {
             const agedOutPaths = new Set(agedOut.map((entry) => entry.path));
             remaining = remaining.filter((entry) => !agedOutPaths.has(entry.path));
@@ -54,7 +54,7 @@ export async function cleanupArtifacts(options) {
     if (config.maxTotalBytes > 0) {
         let totalBytes = remaining.reduce((sum, entry) => sum + entry.size, 0);
         if (totalBytes > config.maxTotalBytes) {
-            const sizeCandidates = [...remaining].sort((a, b) => a.mtimeMs - b.mtimeMs);
+            const sizeCandidates = [...remaining].toSorted((a, b) => a.mtimeMs - b.mtimeMs);
             const removedPaths = new Set();
             for (const entry of sizeCandidates) {
                 if (totalBytes <= config.maxTotalBytes)

package/dist/src/utils/betterSqlite3.d.ts

@@ -0,0 +1,11 @@
+export type BetterSqlite3Issue = 'missing' | 'abi-mismatch' | 'load-failed';
+export interface BetterSqlite3ProbeResult {
+    status: 'ok' | 'missing' | 'warn';
+    detail: string;
+    version: string | null;
+    issue?: BetterSqlite3Issue;
+}
+export declare function isBetterSqlite3RelatedError(error: unknown): boolean;
+export declare function classifyBetterSqlite3Issue(error: unknown): BetterSqlite3Issue;
+export declare function formatBetterSqlite3Error(error: unknown): string;
+export declare function probeBetterSqlite3(): BetterSqlite3ProbeResult;