@qvac/harness 0.1.0 → 0.1.1

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

@@ -0,0 +1,75 @@
+import type { ExecResult } from '../../runner.ts';
+export type PyodideLike = {
+    runPython(code: string, options?: {
+        filename?: string;
+    }): unknown;
+    runPythonAsync(code: string): Promise<unknown>;
+    loadPackage(name: string): Promise<unknown>;
+    setStdout(options: {
+        batched: (output: string) => void;
+    }): void;
+    setStderr(options: {
+        batched: (output: string) => void;
+    }): void;
+    setInterruptBuffer(buffer: Uint8Array): void;
+    globals: {
+        set(key: string, value: unknown): void;
+        get(key: string): unknown;
+    };
+    FS: {
+        mkdirTree(path: string): void;
+        chdir(path: string): void;
+        cwd(): string;
+        writeFile(path: string, data: Uint8Array): void;
+        readFile(path: string, opts: {
+            encoding: 'binary';
+        }): Uint8Array;
+        analyzePath(path: string): {
+            exists: boolean;
+        };
+        readdir(path: string): string[];
+        stat(path: string): {
+            mode: number;
+            size: number;
+        };
+        lstat(path: string): {
+            mode: number;
+        };
+        isDir(mode: number): boolean;
+        isLink(mode: number): boolean;
+        unlink(path: string): void;
+        rmdir(path: string): void;
+    };
+};
+export type LoadPyodideFn = () => Promise<PyodideLike>;
+export type PythonRunResult = ExecResult & {
+    files?: ReadonlyMap<string, Uint8Array>;
+    missing?: readonly string[];
+    rejected?: readonly {
+        name: string;
+        reason: string;
+    }[];
+    undeclared?: readonly string[];
+};
+export type RunSpec = {
+    readonly code: string;
+    readonly packages?: readonly string[] | undefined;
+    readonly inputs?: readonly {
+        readonly path: string;
+        readonly bytes: Uint8Array;
+    }[] | undefined;
+    readonly outputs?: readonly string[] | undefined;
+    readonly workdir?: string | undefined;
+    readonly maxOutputChars: number;
+    readonly installTimeoutMs: number;
+};
+export type RunOutcome = {
+    readonly result: PythonRunResult;
+    readonly evict: boolean;
+};
+export declare function cap(text: string, limit: number): string;
+export declare function isPyodideFatal(error: unknown): boolean;
+export declare function repairDoubleEscapedSource(code: string, message: string): string | null;
+export declare function performRun(py: PyodideLike, spec: RunSpec, opts?: {
+    readonly isCancelled?: () => boolean;
+}): Promise<RunOutcome>;

package/dist-lib/lib/tools/exec/adapters/python/run-session.js

@@ -0,0 +1,273 @@
+import { AbortedError } from "../../../../helpers/race-abort.js";
+import { hlog } from "../../../../log.js";
+import { TRUNCATED_OUTPUT_SUFFIX } from "../../runner.js";
+import { collectOutputs, openScratch, stageInputFiles } from "./memfs.js";
+import { planVendoredInstall, stageVendoredWheels } from "./wheels.js";
+export function cap(text, limit) {
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, limit)}${TRUNCATED_OUTPUT_SUFFIX}`;
+}
+export function isPyodideFatal(error) {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    if ('pyodide_fatal_error' in error && error.pyodide_fatal_error === true)
+        return true;
+    return error instanceof Error && error.message.includes('and can no longer be used');
+}
+const DOUBLE_ESCAPED = /\\[nt"']/;
+function unescapeSource(code) {
+    return code.replace(/\\(n|t|r|"|'|\\)/g, (_, char) => {
+        if (char === 'n')
+            return '\n';
+        if (char === 't')
+            return '\t';
+        if (char === 'r')
+            return '\r';
+        return char;
+    });
+}
+export function repairDoubleEscapedSource(code, message) {
+    if (!message.includes('SyntaxError'))
+        return null;
+    if (code.includes('\n'))
+        return null;
+    if (!DOUBLE_ESCAPED.test(code))
+        return null;
+    const repaired = unescapeSource(code);
+    return repaired === code ? null : repaired;
+}
+function attempt(py, code, output, maxOutputChars) {
+    try {
+        py.runPython(code);
+        return {
+            result: {
+                stdout: cap(output.stdout, maxOutputChars),
+                stderr: cap(output.stderr, maxOutputChars),
+                exitCode: 0
+            },
+            error: null,
+            fatal: false
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            result: {
+                stdout: cap(output.stdout, maxOutputChars),
+                stderr: cap(output.stderr || message, maxOutputChars),
+                exitCode: 1
+            },
+            error: message,
+            fatal: isPyodideFatal(error)
+        };
+    }
+}
+function runOnce(py, code, output, maxOutputChars) {
+    const first = attempt(py, code, output, maxOutputChars);
+    if (first.error === null)
+        return first;
+    const repaired = repairDoubleEscapedSource(code, first.error);
+    if (repaired === null)
+        return first;
+    const retry = attempt(py, repaired, output, maxOutputChars);
+    if (retry.error !== null && retry.error.includes('SyntaxError'))
+        return first;
+    return retry;
+}
+const FIT_DECKS = `
+def _qvac_fit_decks(names):
+    try:
+        from pptx import Presentation
+        from pptx.oxml.ns import qn
+    except Exception:
+        return
+    for name in names:
+        if not name.lower().endswith('.pptx'):
+            continue
+        try:
+            prs = Presentation(name)
+        except Exception:
+            continue
+        slide_height = prs.slide_height
+        changed = False
+        for slide in prs.slides:
+            for shape in slide.shapes:
+                if not shape.has_text_frame:
+                    continue
+                tf = shape.text_frame
+                text = tf.text or ''
+                if not text.strip():
+                    continue
+                tf.word_wrap = True
+                # Estimated wrapped lines against the box: a character at N pt is
+                # about 0.5 N wide and a line about 1.2 N tall. Rough on purpose —
+                # it only has to pick a scale, and the renderer does the real layout.
+                width_pt = (shape.width or 0) / 12700.0
+                height_pt = (shape.height or slide_height) / 12700.0
+                lines = 0
+                tallest = 0.0
+                for p in tf.paragraphs:
+                    # An unsized paragraph inherits from the layout, and the bundled
+                    # template's body is 28pt — assuming something smaller here is
+                    # what let a seven-bullet slide measure as fitting.
+                    size = p.font.size.pt if p.font.size is not None else 28.0
+                    tallest = max(tallest, size)
+                    per_line = max(1.0, width_pt / (size * 0.5))
+                    lines += max(1, int(len(p.text or '') / per_line) + 1)
+                needed = lines * max(tallest, 12.0) * 1.2
+                scale = 1.0 if needed <= height_pt or height_pt <= 0 else height_pt / needed
+                # 55% is the floor: below that the deck is unreadable from a room and
+                # the honest answer is fewer bullets, not smaller type.
+                scale = max(0.55, min(1.0, scale))
+                bodyPr = tf._txBody.bodyPr
+                for tag in ('a:normAutofit', 'a:spAutoFit', 'a:noAutofit'):
+                    found = bodyPr.find(qn(tag))
+                    if found is not None:
+                        bodyPr.remove(found)
+                bodyPr.append(
+                    bodyPr.makeelement(
+                        qn('a:normAutofit'),
+                        {
+                            'fontScale': str(int(scale * 100000)),
+                            'lnSpcReduction': '0' if scale >= 1.0 else '10000'
+                        }
+                    )
+                )
+                changed = True
+        if changed:
+            try:
+                prs.save(name)
+            except Exception:
+                pass
+`;
+class InstallTimeoutError extends Error {
+}
+function installSource(py, packages) {
+    const plan = planVendoredInstall(packages);
+    if (!plan)
+        return `import micropip\nawait micropip.install(${JSON.stringify(packages)})`;
+    const specs = [...stageVendoredWheels(py.FS, plan), ...plan.packages];
+    hlog('python: installing from vendored wheels', { specs });
+    return `import micropip\nawait micropip.install(${JSON.stringify(specs)}, deps=False)`;
+}
+async function installPackages(py, packages, timeoutMs, isCancelled) {
+    await py.loadPackage('micropip');
+    if (isCancelled())
+        throw new AbortedError();
+    const install = py.runPythonAsync(installSource(py, packages));
+    let timer;
+    const bound = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new InstallTimeoutError(`package install timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        await Promise.race([install, bound]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+const DELIVERABLE = /\.(pptx|docx|xlsx|pdf|png|jpe?g|gif|webp|csv|json|txt|md|zip)$/i;
+function listFiles(py, dir) {
+    try {
+        return new Set(py.FS.readdir(dir).filter((name) => name !== '.' && name !== '..'));
+    }
+    catch {
+        return new Set();
+    }
+}
+function newDeliverables(before, after) {
+    return [...after].filter((name) => !before.has(name) && DELIVERABLE.test(name));
+}
+function fitDecks(py, outputs) {
+    if (!outputs.some((name) => name.toLowerCase().endsWith('.pptx')))
+        return false;
+    try {
+        py.runPython(`${FIT_DECKS}\n_qvac_fit_decks(${JSON.stringify(outputs)})`);
+        return false;
+    }
+    catch (error) {
+        hlog('python: deck fit skipped', {
+            err: error instanceof Error ? error.message : String(error)
+        });
+        return isPyodideFatal(error);
+    }
+}
+export async function performRun(py, spec, opts = {}) {
+    const isCancelled = opts.isCancelled ?? (() => false);
+    const output = { stdout: '', stderr: '' };
+    py.setStdout({ batched: (chunk) => (output.stdout += chunk + '\n') });
+    py.setStderr({ batched: (chunk) => (output.stderr += chunk + '\n') });
+    if (spec.packages?.length) {
+        if (isCancelled())
+            throw new AbortedError();
+        hlog('python: installing packages', {
+            packages: [...spec.packages],
+            timeoutMs: spec.installTimeoutMs
+        });
+        try {
+            await installPackages(py, spec.packages, spec.installTimeoutMs, isCancelled);
+            hlog('python: packages ready', { packages: [...spec.packages] });
+        }
+        catch (error) {
+            if (error instanceof AbortedError)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            const timedOut = error instanceof InstallTimeoutError;
+            const evict = timedOut || isPyodideFatal(error);
+            hlog(timedOut ? 'python: package install timed out' : 'python: package install failed', {
+                packages: [...spec.packages],
+                err: message,
+                evict
+            });
+            return {
+                result: { stdout: '', stderr: cap(message, spec.maxOutputChars), exitCode: 1 },
+                evict
+            };
+        }
+        output.stdout = '';
+        output.stderr = '';
+    }
+    if (isCancelled())
+        throw new AbortedError();
+    if (!spec.inputs?.length && !spec.outputs?.length && !spec.workdir) {
+        const cwd = py.FS.cwd();
+        const before = listFiles(py, cwd);
+        const { result, fatal } = runOnce(py, spec.code, output, spec.maxOutputChars);
+        if (result.exitCode !== 0)
+            return { result, evict: fatal };
+        const undeclared = newDeliverables(before, listFiles(py, cwd));
+        return { result: undeclared.length > 0 ? { ...result, undeclared } : result, evict: false };
+    }
+    const scratch = openScratch(py.FS, spec.workdir);
+    try {
+        py.FS.chdir(scratch.cwd);
+        stageInputFiles(py.FS, scratch.cwd, spec.inputs ?? []);
+        const before = listFiles(py, scratch.cwd);
+        const { result, fatal } = runOnce(py, spec.code, output, spec.maxOutputChars);
+        let evict = fatal;
+        if (result.exitCode === 0)
+            evict = fitDecks(py, spec.outputs ?? []);
+        if (evict)
+            return { result: { ...result, missing: spec.outputs ?? [] }, evict };
+        const outputs = collectOutputs(py.FS, scratch.cwd, spec.outputs ?? []);
+        const declared = new Set(spec.outputs ?? []);
+        const undeclared = result.exitCode === 0
+            ? newDeliverables(before, listFiles(py, scratch.cwd)).filter((name) => !declared.has(name))
+            : [];
+        return {
+            result: {
+                ...result,
+                files: outputs.files,
+                missing: outputs.missing,
+                rejected: outputs.rejected,
+                ...(undeclared.length > 0 && { undeclared })
+            },
+            evict: false
+        };
+    }
+    finally {
+        scratch[Symbol.dispose]();
+    }
+}

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+declare const ManifestSchema: z.ZodObject<{
+    pyodide: z.ZodString;
+    packages: z.ZodRecord<z.ZodString, z.ZodObject<{
+        version: z.ZodOptional<z.ZodString>;
+        pypi: z.ZodArray<z.ZodString>;
+        pyodide: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    files: z.ZodRecord<z.ZodString, z.ZodObject<{
+        url: z.ZodString;
+        sha256: z.ZodString;
+        channel: z.ZodEnum<{
+            pyodide: "pyodide";
+            pypi: "pypi";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WheelManifest = z.infer<typeof ManifestSchema>;
+export type VendoredInstall = {
+    readonly wheels: readonly string[];
+    readonly packages: readonly string[];
+};
+type WheelFs = {
+    mkdirTree(path: string): void;
+    writeFile(path: string, data: Uint8Array): void;
+    analyzePath(path: string): {
+        exists: boolean;
+    };
+};
+export declare function wheelsDir(): string | undefined;
+export declare function vendoredManifest(dir?: string | undefined): WheelManifest | null;
+export declare function planVendoredInstall(specs: readonly string[], opts?: {
+    readonly dir?: string | undefined;
+    readonly manifest?: WheelManifest | null;
+}): VendoredInstall | null;
+export declare function stageVendoredWheels(target: WheelFs, install: VendoredInstall): string[];
+export declare function seedPackageCache(cacheDir: string, dir?: string | undefined): void;
+export {};

package/dist-lib/lib/tools/exec/adapters/python/wheels.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import process from 'process';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import { hlog } from "../../../../log.js";
+const ManifestSchema = z.object({
+    pyodide: z.string(),
+    packages: z.record(z.string(), z.object({
+        version: z.string().optional(),
+        pypi: z.array(z.string()),
+        pyodide: z.array(z.string())
+    })),
+    files: z.record(z.string(), z.object({ url: z.string(), sha256: z.string(), channel: z.enum(['pypi', 'pyodide']) }))
+});
+const STAGE_DIR = '/qvac-wheels';
+export function wheelsDir() {
+    const fromHost = process.env.QVAC_PYTHON_WHEELS_DIR;
+    if (fromHost)
+        return fromHost;
+    const source = new URL('../../../../../wheels', import.meta.url);
+    if (source.href.includes('.bundle/'))
+        return undefined;
+    return fileURLToPath(source.href);
+}
+export function vendoredManifest(dir = wheelsDir()) {
+    if (!dir)
+        return null;
+    const file = `${dir}/manifest.json`;
+    if (!fs.existsSync(file)) {
+        hlog('python: no vendored wheels', { dir });
+        return null;
+    }
+    try {
+        return ManifestSchema.parse(JSON.parse(fs.readFileSync(file, 'utf8')));
+    }
+    catch (error) {
+        hlog('python: vendored wheel manifest unusable', {
+            file,
+            err: error instanceof Error ? error.message : String(error)
+        });
+        return null;
+    }
+}
+function normalize(name) {
+    return name.toLowerCase().replace(/[_.]+/g, '-');
+}
+function parseSpec(spec) {
+    const [name, version] = spec.split('==');
+    return { name: normalize((name ?? '').trim()), version: version?.trim() };
+}
+export function planVendoredInstall(specs, opts = {}) {
+    const dir = opts.dir ?? wheelsDir();
+    const manifest = opts.manifest === undefined ? vendoredManifest(dir) : opts.manifest;
+    if (!manifest || !dir || specs.length === 0)
+        return null;
+    const wheels = new Set();
+    const packages = new Set();
+    for (const spec of specs) {
+        const { name, version } = parseSpec(spec);
+        const entry = manifest.packages[name];
+        if (!entry || entry.version !== version)
+            return null;
+        for (const wheel of entry.pypi) {
+            if (!fs.existsSync(`${dir}/${wheel}`)) {
+                hlog('python: vendored wheel missing, installing from PyPI instead', { wheel });
+                return null;
+            }
+            wheels.add(`${dir}/${wheel}`);
+        }
+        for (const dependency of entry.pyodide)
+            packages.add(dependency);
+    }
+    return { wheels: [...wheels], packages: [...packages] };
+}
+export function stageVendoredWheels(target, install) {
+    if (install.wheels.length > 0)
+        target.mkdirTree(STAGE_DIR);
+    return install.wheels.map((wheel) => {
+        const staged = `${STAGE_DIR}/${wheel.slice(wheel.lastIndexOf('/') + 1)}`;
+        if (!target.analyzePath(staged).exists) {
+            target.writeFile(staged, new Uint8Array(fs.readFileSync(wheel)));
+        }
+        return `emfs:${staged}`;
+    });
+}
+export function seedPackageCache(cacheDir, dir = wheelsDir()) {
+    const manifest = vendoredManifest(dir);
+    if (!manifest || !dir)
+        return;
+    fs.mkdirSync(cacheDir, { recursive: true });
+    let seeded = 0;
+    for (const [file, entry] of Object.entries(manifest.files)) {
+        if (entry.channel !== 'pyodide' || fs.existsSync(`${cacheDir}/${file}`))
+            continue;
+        if (!fs.existsSync(`${dir}/${file}`))
+            continue;
+        fs.copyFileSync(`${dir}/${file}`, `${cacheDir}/${file}`);
+        seeded++;
+    }
+    if (seeded > 0)
+        hlog('python: seeded package cache', { cacheDir, wheels: seeded });
+}

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

@@ -0,0 +1,7 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { PythonRunResult, RunSpec } from '../run-session.ts';
+export declare function runPythonInWorker(spec: RunSpec, opts: {
+    readonly timeoutMs: number;
+    readonly signal?: BareAbortSignal | undefined;
+}): Promise<PythonRunResult>;
+export declare function closePythonWorker(): Promise<void>;

package/dist-lib/lib/tools/exec/adapters/python/worker/client.js

@@ -0,0 +1,188 @@
+import { spawnPythonWorker } from '#pyodide-worker-spawn';
+import process from 'process';
+import { fileURLToPath } from 'url';
+import { AbortedError, raceAbort } from "../../../../../helpers/race-abort.js";
+import { harnessLogEnabled, hlog } from "../../../../../log.js";
+import { asWorkerMessage, fromWireResult } from "./protocol.js";
+const SIGINT = 2;
+function interruptGraceMs() {
+    const ms = Number(process.env.QVAC_PYODIDE_INTERRUPT_GRACE_MS);
+    return ms > 0 ? ms : 30_000;
+}
+const SHUTDOWN_GRACE_MS = 3_000;
+let active = null;
+function workerEntry() {
+    return (process.env.QVAC_PYODIDE_WORKER_ENTRY ??
+        fileURLToPath(new URL('./entry.ts', import.meta.url).href));
+}
+async function readMessage(link) {
+    for (;;) {
+        const message = asWorkerMessage(await link.read());
+        if (message?.type !== 'log')
+            return message;
+        hlog(`python worker: ${message.message}`);
+    }
+}
+async function awaitReady(link) {
+    const message = await readMessage(link);
+    if (message?.type === 'ready')
+        return;
+    if (message?.type === 'boot-error')
+        throw new Error(`python worker: ${message.message}`);
+    throw new Error('python worker sent an unexpected first message');
+}
+function boot() {
+    hlog('python: booting worker thread');
+    const sab = new SharedArrayBuffer(1);
+    const link = spawnPythonWorker(workerEntry(), { sab, log: harnessLogEnabled() });
+    const worker = {
+        link,
+        view: new Uint8Array(sab),
+        ready: awaitReady(link).then(() => hlog('python: worker ready')),
+        nextId: 1
+    };
+    worker.ready.catch(() => {
+        if (active === worker)
+            active = null;
+        link.kill();
+    });
+    return worker;
+}
+function destroy(worker) {
+    if (active === worker)
+        active = null;
+    worker.link.kill();
+}
+async function drainAndReap(worker) {
+    if (active === worker)
+        active = null;
+    const closed = readMessage(worker.link).then(() => 'message', () => 'closed');
+    const timer = grace(SHUTDOWN_GRACE_MS);
+    try {
+        const settled = await Promise.race([closed, timer.expired]);
+        if (settled === 'closed')
+            worker.link.reap();
+        else
+            worker.link.kill();
+    }
+    finally {
+        timer.clear();
+    }
+}
+async function resultFor(worker, id) {
+    const message = await readMessage(worker.link);
+    if (message?.type === 'result') {
+        if (message.id !== id)
+            throw new Error('python worker answered a different run');
+        return { result: fromWireResult(message.result), evict: message.evict };
+    }
+    if (message?.type === 'boot-error')
+        throw new Error(`python worker: ${message.message}`);
+    throw new Error('python worker sent an unexpected message');
+}
+function grace(ms) {
+    let timer;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('grace'), ms);
+    });
+    return { expired, clear: () => clearTimeout(timer) };
+}
+async function interrupt(worker, outcome) {
+    Atomics.store(worker.view, 0, SIGINT);
+    const graceMs = interruptGraceMs();
+    const timer = grace(graceMs);
+    try {
+        const settled = await Promise.race([
+            outcome.then(() => 'done', () => 'done'),
+            timer.expired
+        ]);
+        if (settled === 'grace') {
+            hlog('python: worker ignored interrupt; killing', { graceMs });
+            destroy(worker);
+        }
+        else {
+            Atomics.store(worker.view, 0, 0);
+        }
+    }
+    finally {
+        timer.clear();
+    }
+}
+export async function runPythonInWorker(spec, opts) {
+    const worker = (active ??= boot());
+    worker.link.ref();
+    try {
+        const id = worker.nextId++;
+        Atomics.store(worker.view, 0, 0);
+        let cancelled = false;
+        let sent = false;
+        const outcome = (async () => {
+            await worker.ready;
+            if (cancelled)
+                throw new AbortedError();
+            sent = true;
+            await worker.link.write({ type: 'run', id, spec });
+            return resultFor(worker, id);
+        })();
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => resolve('timeout'), opts.timeoutMs);
+        });
+        let first;
+        try {
+            first = await raceAbort(Promise.race([outcome, timeout]), opts.signal);
+        }
+        catch (error) {
+            if (error instanceof AbortedError) {
+                cancelled = true;
+                if (sent)
+                    await interrupt(worker, outcome);
+                else
+                    outcome.catch(() => { });
+                throw error;
+            }
+            destroy(worker);
+            throw error;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+        if (first === 'timeout') {
+            cancelled = true;
+            if (sent)
+                await interrupt(worker, outcome);
+            else
+                outcome.catch(() => { });
+            throw new Error(`Command timed out after ${opts.timeoutMs}ms`);
+        }
+        if (first.evict)
+            await drainAndReap(worker);
+        return first.result;
+    }
+    finally {
+        worker.link.unref();
+    }
+}
+export async function closePythonWorker() {
+    const worker = active;
+    if (!worker)
+        return;
+    active = null;
+    const timer = grace(SHUTDOWN_GRACE_MS);
+    try {
+        const booted = await Promise.race([worker.ready.then(() => 'ready'), timer.expired]);
+        if (booted === 'grace') {
+            worker.link.kill();
+            return;
+        }
+        await worker.link.write({ type: 'close' });
+        await drainAndReap(worker);
+    }
+    catch {
+        worker.link.kill();
+    }
+    finally {
+        timer.clear();
+    }
+}

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

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