@qvac/harness 0.8.0 → 0.8.6

package/dist-lib/lib/models/model-pool.js

@@ -11,6 +11,7 @@ import { RUNAWAY_STOP_SEQUENCES } from '../helpers/control-tokens.js';
 import { raceTimeout } from '../helpers/race-timeout.js';
 import { resolveModelSrc } from './model-source.js';
 import { errorMessage } from '../guards.js';
+import { AbortedError } from '../helpers/race-abort.js';
 export function createLoadTracker() {
     const inflight = new Set();
     let draining = null;
@@ -73,10 +74,14 @@ function entryOf(pool, key) {
 export function modelOf(key) {
     return key.split('\0')[0];
 }
+let uses = 0;
 export function releaseModel(pool, key) {
     if (pool.destroyed)
         return;
     const handle = entryOf(pool, key)?.value;
+    if (handle) {
+        handle.lastUsed = ++uses;
+    }
     if (handle === undefined || !handle.loading) {
         pool.release(key);
         return;
@@ -86,8 +91,18 @@ export function releaseModel(pool, key) {
         pool.release(key);
         return;
     }
-    void pending.then(() => releaseSettled(pool, key), () => releaseSettled(pool, key));
+    const deferred = (deferredReleases.get(handle) ?? 0) + 1;
+    deferredReleases.set(handle, deferred);
+    if (deferred >= (entryOf(pool, key)?.refs ?? 0)) {
+        handle.abandon();
+    }
+    const settle = () => {
+        deferredReleases.set(handle, (deferredReleases.get(handle) ?? 1) - 1);
+        releaseSettled(pool, key);
+    };
+    void pending.then(settle, settle);
 }
+const deferredReleases = new WeakMap();
 function releaseSettled(pool, key) {
     if (!pool.destroyed) {
         pool.release(key);
@@ -111,6 +126,21 @@ export function settledModels(pool) {
     }
     return out;
 }
+export function settledEntries(pool) {
+    const out = [];
+    for (const entry of pool.resources.values()) {
+        const resource = entry.value.resource;
+        if (resource !== null) {
+            out.push({
+                key: entry.id,
+                refs: entry.refs,
+                bytes: resource.bytes,
+                lastUsed: entry.value.lastUsed
+            });
+        }
+    }
+    return out;
+}
 export function loadingModels(pool) {
     const out = [];
     for (const entry of pool.resources.values()) {
@@ -120,14 +150,19 @@ export function loadingModels(pool) {
     }
     return out;
 }
-function reportedHandle(notify, model, load) {
+function reportedHandle({ notify, model, addon, hold, load }) {
     return new ModelHandle({
-        load: () => {
+        load: async (signal) => {
+            await hold?.(model, addon, signal);
             notify({ status: 'loading', model, catalogChanged: true });
             return load();
         },
         onLoaded: () => notify({ status: 'ready', model, catalogChanged: true }),
-        onFailed: (err) => notify({ status: 'error', model, message: errorMessage(err), catalogChanged: true })
+        onFailed: (err) => {
+            if (err instanceof AbortedError)
+                return;
+            notify({ status: 'error', model, message: errorMessage(err), catalogChanged: true });
+        }
     });
 }
 export async function leaseResidentModel(pool, wanted = () => true) {
@@ -226,6 +261,10 @@ export async function awaitModelCapacity(pool, { cap, deadlineMs, tickMs = 250,
 export function evictModelWithin(pool, key, options) {
     return evictWhereWithin(pool, (candidate) => candidate === key, options);
 }
+export function evictIdleWithin(pool, key, { deadlineMs }) {
+    const evicting = evictIdleWhere(pool, (candidate) => candidate === key).then(() => !isResident(pool, key));
+    return raceTimeout(evicting, { ms: deadlineMs, fallback: false });
+}
 export function evictModel(pool, model, options) {
     return evictWhereWithin(pool, (key) => modelOf(key) === model, options);
 }
@@ -318,8 +357,8 @@ export function loadClockGuard(model, sdk, { now = () => Date.now(), monoMs = mo
     };
     return { race };
 }
-export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker() } = {}) {
-    const load = async (model, opts) => {
+export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = createLoadTracker(), beforeLoad, hold } = {}) {
+    const load = async (key, model, opts) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model);
         const resolved = resolveLoadOptions(opts, deviceConfig);
@@ -352,54 +391,80 @@ export function createModelPool(loadSdk, notify, { deviceConfig = {}, loads = cr
         });
         const { projectionModelSrc: projection, ...loggedConfig } = modelConfig;
         hlog('llm load config', { model, projection: Boolean(projection), ...loggedConfig });
+        const admission = await beforeLoad?.({
+            key,
+            model,
+            modelSrc,
+            modelType: 'llamacpp-completion',
+            modelConfig
+        });
         const loadStarted = Date.now();
-        const modelId = await loadClockGuard(model, sdk).race(loads.track(sdk.loadModel({
+        const modelId = await loadClockGuard(model, sdk)
+            .race(loads.track(sdk.loadModel({
             modelSrc,
             modelType: 'llamacpp-completion',
             modelConfig,
             onProgress: (progress) => notify(progressState(model, progress))
-        })));
+        })))
+            .finally(() => admission?.release());
         hlog('llm loaded', { model, loadMs: Date.now() - loadStarted });
-        return { model, modelId, ctxSize };
+        return { model, modelId, ctxSize, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key, opts = {}) => reportedHandle(notify, model, () => load(model, opts)),
+        open: (key, model = key, opts = {}) => reportedHandle({ notify, model, addon: 'llm', hold, load: () => load(key, model, opts) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
 }
-export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker() }) {
-    const load = async (model) => {
+export function createEmbedPool(loadSdk, notify, { faults, batchSize = DEFAULT_EMBED_BATCH_SIZE, openclCacheDir, loads = createLoadTracker(), beforeLoad, hold }) {
+    const load = async (key, model) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model, 'embeddings');
         const openclCache = faults.device !== 'cpu' && openclCacheDir ? openclCacheDir() : undefined;
-        const modelId = await loadClockGuard(model, sdk).race(loads.track(sdk.loadModel({
+        const modelConfig = {
+            batchSize,
+            gpuLayers: faults.gpuLayers(),
+            device: faults.device,
+            openclCacheDir: openclCache || undefined
+        };
+        const admission = await beforeLoad?.({
+            key,
+            model,
             modelSrc,
             modelType: 'llamacpp-embedding',
-            modelConfig: {
-                batchSize,
-                gpuLayers: faults.gpuLayers(),
-                device: faults.device,
-                openclCacheDir: openclCache || undefined
-            },
+            modelConfig
+        });
+        const modelId = await loadClockGuard(model, sdk)
+            .race(loads.track(sdk.loadModel({
+            modelSrc,
+            modelType: 'llamacpp-embedding',
+            modelConfig,
             onProgress: (progress) => notify(progressState(model, progress))
-        })));
-        return { model, modelId };
+        })))
+            .finally(() => admission?.release());
+        return { model, modelId, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key) => reportedHandle(notify, model, () => load(model)),
+        open: (key, model = key) => reportedHandle({ notify, model, addon: 'embeddings', hold, load: () => load(key, model) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
 }
-export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, modelConfigFor, openclCacheDir, loads = createLoadTracker() }) {
+export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig, modelConfigFor, openclCacheDir, loads = createLoadTracker(), beforeLoad, hold }) {
     const wantsGpu = modelConfig?.['useGPU'] === true;
     let gpuRefused = false;
-    const load = async (model) => {
+    const load = async (key, model) => {
         const sdk = await loadSdk();
         const modelSrc = await resolveModelSrc(sdk, model, addon);
         const tuned = modelConfigFor?.(modelSrc);
         const loadConfig = tuned ? { ...modelConfig, ...tuned } : modelConfig;
+        const admission = await beforeLoad?.({
+            key,
+            model,
+            modelSrc,
+            modelType,
+            modelConfig: loadConfig
+        });
         const attempt = () => {
             const config = gpuRefused ? { ...loadConfig, useGPU: false } : loadConfig;
             const openclCache = gpuRefused ? undefined : openclCacheDir?.();
@@ -410,17 +475,19 @@ export function createVoicePool(loadSdk, notify, { modelType, addon, modelConfig
                 onProgress: (progress) => notify(progressState(model, progress))
             }));
         };
-        const modelId = await loadClockGuard(model, sdk).race(attempt().catch((err) => {
+        const modelId = await loadClockGuard(model, sdk)
+            .race(attempt().catch((err) => {
             if (!wantsGpu || gpuRefused || loads.draining)
                 throw err;
             hlog('voice gpu load refused, retrying on cpu', { model, modelType, error: String(err) });
             gpuRefused = true;
             return attempt();
-        }));
-        return { model, modelId };
+        }))
+            .finally(() => admission?.release());
+        return { model, modelId, bytes: admission?.bytes };
     };
     return new ModelPuddle({
-        open: (key, model = key) => reportedHandle(notify, model, () => load(model)),
+        open: (key, model = key) => reportedHandle({ notify, model, addon, hold, load: () => load(key, model) }),
         gc: unloadOnGc(loadSdk, notify),
         ...NO_IDLE_GC
     });
@@ -445,7 +512,8 @@ function unloadOnGc(loadSdk, notify) {
             try {
                 await sdk.unloadModel({ modelId });
             }
-            catch {
+            catch (err) {
+                hlog('unload failed', { model, err: errorMessage(err) });
                 continue;
             }
             notify({ status: 'unloaded', model, catalogChanged: true });

package/dist-lib/lib/office/extract.d.ts

@@ -0,0 +1,9 @@
+import type { AbortSignal } from 'bare-abort-controller';
+export type Extract = (bytes: Uint8Array) => string;
+export interface ExtractJob {
+    readonly fileName: string;
+    readonly signal: AbortSignal | undefined;
+    readonly extract: Extract;
+}
+export declare function extractWith(bytes: Uint8Array, { fileName, signal, extract }: ExtractJob): string;
+export declare function cellText(value: unknown): string;

package/dist-lib/lib/office/extract.js

@@ -0,0 +1,19 @@
+import { errorMessage } from '../guards.js';
+const MAX_OFFICE_BYTES = 20 * 1024 * 1024;
+export function extractWith(bytes, { fileName, signal, extract }) {
+    if (bytes.byteLength > MAX_OFFICE_BYTES) {
+        throw new Error(`document is too large to extract: ${bytes.byteLength} bytes, limit ${MAX_OFFICE_BYTES}`);
+    }
+    if (signal?.aborted) {
+        throw new Error(`${fileName}: extraction aborted`);
+    }
+    try {
+        return extract(bytes);
+    }
+    catch (err) {
+        throw new Error(`${fileName}: ${errorMessage(err)}`);
+    }
+}
+export function cellText(value) {
+    return value === null || value === undefined ? '' : String(value).replaceAll('\n', ' ');
+}

package/dist-lib/lib/office/index.d.ts

@@ -1,5 +1,5 @@
 import type { AbortSignal } from 'bare-abort-controller';
-export { closePythonWorker as closeOfficeWorker } from '../tools/exec/adapters/python/worker/active.ts';
+export { closeDocxWorker as closeOfficeWorker } from '../docx/index.ts';
 export interface OfficeExtractOptions {
     readonly signal?: AbortSignal | undefined;
     readonly mimeType?: string | undefined;

package/dist-lib/lib/office/index.js

@@ -1,14 +1,81 @@
 import path from 'path';
 import { extractDocxText } from '../docx/index.js';
-import { extractWithPython } from './python.js';
-import { XLSX_EXTRACT } from './xlsx.js';
-import { PPTX_EXTRACT } from './pptx.js';
-export { closePythonWorker as closeOfficeWorker } from '../tools/exec/adapters/python/worker/active.js';
+import { pptx, xlsx } from './engine/index.js';
+import { cellText, extractWith } from './extract.js';
+export { closeDocxWorker as closeOfficeWorker } from '../docx/index.js';
 const OFFICE_MIME_EXTENSIONS = {
     'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
     'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx'
 };
+const EXTRACT_CELL_LIMIT = 1_000_000;
+function columnIndex(letters) {
+    let index = 0;
+    for (const char of letters) {
+        index = index * 26 + char.charCodeAt(0) - 64;
+    }
+    return index;
+}
+function columnName(index) {
+    let name = '';
+    for (let n = index; n > 0; n = Math.floor((n - 1) / 26)) {
+        name = String.fromCharCode(65 + ((n - 1) % 26)) + name;
+    }
+    return name;
+}
+function trimmedRow(values) {
+    const row = [...values];
+    while (row.length && !cellText(row.at(-1)).trim()) {
+        row.pop();
+    }
+    return row;
+}
+function workbookText(bytes) {
+    const book = xlsx.open(bytes);
+    let output = '';
+    let budget = EXTRACT_CELL_LIMIT;
+    for (const sheet of book.sheets()) {
+        if (sheet.kind !== 'worksheet' || budget <= 0)
+            continue;
+        const { range, rows, formulas } = book.read(sheet.index, { limit: budget });
+        budget -= rows.length * (rows[0]?.length ?? 0);
+        const [, letters = 'A', digits = '1'] = /^([A-Z]+)(\d+)/.exec(range ?? 'A1') ?? [];
+        const firstColumn = columnIndex(letters);
+        const firstRow = Number(digits);
+        const lines = rows
+            .map((row, r) => trimmedRow(row.map((value, c) => value ?? formulas[`${columnName(firstColumn + c)}${firstRow + r}`] ?? null)))
+            .filter((row) => row.length)
+            .map((row) => row.map(cellText).join(' | '));
+        if (lines.length) {
+            output += `Sheet: ${sheet.name}\n${lines.join('\n')}\n`;
+        }
+    }
+    return output;
+}
+function shapeBlocks(shape) {
+    if (shape.paragraphs) {
+        const text = shape.paragraphs.map((paragraph) => paragraph.text).join('\n');
+        return text.trim() ? [text] : [];
+    }
+    return (shape.rows ?? [])
+        .map((row) => row.map(cellText))
+        .filter((cells) => cells.some((cell) => cell.trim()))
+        .map((cells) => cells.join(' | '));
+}
+function deckText(bytes) {
+    let output = '';
+    for (const slide of pptx.open(bytes).read()) {
+        const blocks = slide.shapes.flatMap(shapeBlocks);
+        if (blocks.length) {
+            output += `Slide ${slide.index + 1}\n${blocks.join('\n')}\n`;
+        }
+    }
+    return output;
+}
+const EXTRACTORS = new Map([
+    ['.xlsx', workbookText],
+    ['.pptx', deckText]
+]);
 export async function extractOfficeText(bytes, fileName, options = {}) {
     const mimeType = options.mimeType?.split(';')[0]?.trim().toLowerCase();
     const suffix = path.extname(fileName).toLowerCase();
@@ -18,21 +85,9 @@ export async function extractOfficeText(bytes, fileName, options = {}) {
     if (extension === '.docx') {
         return extractDocxText(bytes, fileName, options);
     }
-    if (extension === '.xlsx') {
-        return extractWithPython(bytes, fileName, {
-            format: 'XLSX',
-            packages: ['openpyxl==3.1.5'],
-            source: XLSX_EXTRACT,
-            signal: options.signal
-        });
-    }
-    if (extension === '.pptx') {
-        return extractWithPython(bytes, fileName, {
-            format: 'PPTX',
-            packages: ['python-pptx==1.0.2'],
-            source: PPTX_EXTRACT,
-            signal: options.signal
-        });
+    const extract = EXTRACTORS.get(extension ?? '');
+    if (extract) {
+        return extractWith(bytes, { fileName, signal: options.signal, extract });
     }
     throw new Error(`Unsupported Office document: ${fileName}`);
 }

package/dist-lib/lib/serve.js

@@ -23,7 +23,8 @@ const MODEL_STATUSES = new Set([
     'ready',
     'error',
     'unloading',
-    'unloaded'
+    'unloaded',
+    'held'
 ]);
 const DOWNLOAD_PROGRESS_INTERVAL_MS = 500;
 const WIRE_HIGH_WATER_MARK = 64;
@@ -50,6 +51,20 @@ export function serveHarness(stream, harness) {
             await harness.setModelIdleTimeout?.(ms);
             return { ok: true };
         },
+        setModelMemoryCap: async ({ percent }) => {
+            await harness.setModelMemoryCap?.(percent);
+            return { ok: true };
+        },
+        memoryUsage: async () => {
+            if (!harness.memoryUsage) {
+                throw new Error('harness does not support memoryUsage');
+            }
+            return harness.memoryUsage();
+        },
+        setDownloadsAllowed: async ({ allowed }) => {
+            await harness.setDownloadsAllowed?.({ allowed: allowed === true });
+            return { ok: true };
+        },
         listManagedSkills: async () => ({
             skills: (await harness.listManagedSkills?.()) ?? []
         }),
@@ -282,7 +297,8 @@ function modelEvents(harness) {
             total,
             message: state.message,
             catalogChanged,
-            loaded
+            loaded,
+            addon: state.addon
         };
         const now = Date.now();
         if (state.status === 'downloading') {

package/dist-lib/lib/tools/exec/adapters/python/module-distributions.js

@@ -20,12 +20,10 @@ export const MODULE_DISTRIBUTIONS = {
     cvxpy: 'cvxpy-base',
     dateutil: 'python-dateutil',
     dns: 'dnspython',
-    docx: 'python-docx',
     erfa: 'pyerfa',
     fitz: 'PyMuPDF',
     flint: 'python-flint',
     flirt: 'python-flirt',
-    fpdf: 'fpdf2',
     google: 'protobuf',
     gridfs: 'pymongo',
     isympy: 'sympy',
@@ -33,7 +31,6 @@ export const MODULE_DISTRIBUTIONS = {
     mpl_toolkits: 'matplotlib',
     mypyc: 'mypy',
     nacl: 'pynacl',
-    pptx: 'python-pptx',
     pygame: 'pygame-ce',
     pylab: 'matplotlib',
     pysat: 'python-sat',

package/dist-lib/lib/tools/exec/adapters/python/python-adapter.d.ts

@@ -1,8 +1,7 @@
-import type { ExecAttachment } from '../../runner.ts';
 import type { ExecutionAdapter } from '../adapter.ts';
 import { type ExecInput } from './attachments.ts';
 import { type ExecError } from './output-policy.ts';
-import { type LoadPyodideFn, type PythonRunResult } from './pyodide.ts';
+import { type LoadPyodideFn } from './pyodide.ts';
 export declare function isPythonLanguage(language: unknown): boolean;
 export declare function runsThroughPyodide(language: unknown, disablePyodide: boolean): boolean;
 export declare function unwrapPythonSource(command: string): string | null;
@@ -20,70 +19,28 @@ export interface PipFromSourceHintOptions {
 export declare function pipFromSourceHint(stderr: string, source: string, { packages, sandbox }?: PipFromSourceHintOptions): string | null;
 export declare function stringLiteralProgramHint(source: string): string | null;
 export declare function checkCollapsedCompound(source: string): string | null;
-export declare function mangledPptxApiHint(source: string): string | null;
-export declare function wrongRgbColorHint(source: string): string | null;
-export declare function fpdfSizeKeywordHint(source: string): string | null;
-export declare function fpdfKeywordErrorHint(stderr: string): string | null;
-export declare function normalizeFpdfSource(source: string): string;
-export declare function fpdfTextCallHint(source: string): string | null;
-export declare function fpdfTextErrorHint(stderr: string): string | null;
-export declare function fpdfNonLatin1Hint(source: string): string | null;
-export declare function fpdfUnicodeErrorHint(stderr: string): string | null;
-export declare function fpdfHorizontalSpaceHint(stderr: string): string | null;
-export declare function rgbColorImportHint(stderr: string): string | null;
 export declare function checkPythonSource(command: string): string | null;
 export declare function syntaxErrorHint(stderr: string, source: string): string | null;
-export declare function checkPptxBuildSource(source: string, outputs: readonly string[] | undefined, packages?: readonly string[] | undefined): string | null;
-export declare function tripleQuoteAt(source: string, index: number): string | null;
-export declare function isEscaped(source: string, index: number): boolean;
-export declare function checkBareLengthArgs(source: string, packages?: readonly string[] | undefined): string | null;
-export declare function checkPdfBuildSource(source: string, outputs: readonly string[] | undefined, packages?: readonly string[] | undefined): string | null;
-export declare function stripCommentsAndDocstrings(source: string): string;
-export declare const PDF_READ: RegExp;
-export declare const OFFICE_READ: RegExp;
-export declare function checkUnstagedRead(source: string, inputs: readonly Pick<ExecInput, 'path'>[] | undefined): string | null;
 export declare function missingFileHint(stderr: string): string | null;
 export declare function parsePackages(value: unknown): string[] | ExecError | undefined;
 export declare function parseInputs(value: unknown): ExecInput[] | ExecError | undefined;
 export declare function parseOutputs(value: unknown): string[] | ExecError | undefined;
 export declare function parseWorkdir(value: unknown): string | ExecError | undefined;
+export interface OfficeImportContext {
+    readonly packages: readonly string[] | undefined;
+    readonly toolNames: readonly string[] | undefined;
+}
+export declare function officeModuleHint(stderr: string, toolNames: readonly string[] | undefined): string | null;
+export declare function officeImportError(source: string, { packages, toolNames }: OfficeImportContext): string | null;
 export interface MissingModuleHintOptions {
     readonly packages?: readonly string[] | undefined;
     readonly sandbox?: boolean;
     readonly network?: boolean;
 }
 export declare function missingModuleHint(stderr: string, { packages, sandbox, network }?: MissingModuleHintOptions): string | null;
-export declare function nonePlaceholderHint(stderr: string): string | null;
-export declare function slideShapesHint(stderr: string): string | null;
-export declare function shapeFontHint(stderr: string): string | null;
-export declare function shapesBackgroundHint(stderr: string): string | null;
-export declare function paragraphFillHint(stderr: string): string | null;
-export declare function readOnlyPropertyHint(stderr: string): string | null;
-export declare function paragraphIndexHint(stderr: string, outputs: readonly string[]): string | null;
 export declare function shellNameHint(stderr: string): string | null;
 export declare function noProcessHint(stderr: string, sandbox?: boolean): string | null;
 export declare function noNetworkHint(stderr: string, tools?: readonly string[], network?: boolean): string | null;
 export declare function nativeWheelHint(stderr: string): string | null;
 export declare function packageFetchFailedHint(stderr: string): string | null;
-export declare const IMAGE_INPUT: RegExp;
-export declare function pptxHasEmbeddedMedia(bytes: Uint8Array): boolean;
-export declare function softFailedDeckHint(stdout: string, exitCode: number, source: string): string | null;
-export interface DeckImagesOptions {
-    readonly inputs: readonly {
-        path: string;
-    }[] | undefined;
-    readonly outputs: readonly string[] | undefined;
-    readonly source: string;
-}
-export declare function stagedImagesMissingFromDeck(result: Pick<PythonRunResult, 'exitCode' | 'files'>, { inputs, outputs, source }: DeckImagesOptions): string | null;
-export declare function checkStagedImagesUsed(source: string, inputs: readonly Pick<ExecInput, 'path'>[] | undefined, outputs: readonly string[] | undefined): string | null;
-export interface TurnImagesStagedOptions {
-    readonly inputs: readonly ExecInput[] | undefined;
-    readonly outputs: readonly string[] | undefined;
-    readonly turnImages: readonly {
-        path: string;
-    }[] | undefined;
-}
-export declare function checkTurnImagesStaged(source: string, { inputs, outputs, turnImages }: TurnImagesStagedOptions): string | null;
-export declare function deckDeliveredStop(attachments: readonly Pick<ExecAttachment, 'fileName'>[] | undefined, exitCode: number, source?: string): string | null;
 export declare function createPythonAdapter(disabled: boolean, loadPyodide?: LoadPyodideFn, network?: boolean): ExecutionAdapter;