as-test 1.0.1 → 1.0.3

package/bin/util.js

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync } from "fs";
-import { BuildOptions, Config, CoverageOptions, ModeConfig, ReporterConfig, RunOptions, Runtime, } from "./types.js";
+import { BuildOptions, Config, CoverageOptions, FuzzConfig, ModeConfig, ReporterConfig, RunOptions, Runtime, } from "./types.js";
 import chalk from "chalk";
 import { createRequire } from "module";
-import { delimiter, dirname, join } from "path";
+import { delimiter, dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
 export function formatTime(ms) {
     if (ms < 0) {
@@ -48,9 +48,10 @@ export function loadConfig(CONFIG_PATH, warn = false) {
         }
         const raw = parsed;
         validateConfig(raw, CONFIG_PATH);
+        const configDir = dirname(CONFIG_PATH);
         const config = Object.assign(new Config(), raw);
         applyOutputConfig(raw.output, raw, config);
-        config.env = parseEnvMap(raw.env);
+        config.env = parseEnvValue(raw.env, configDir, "$.env");
         const runOptionsRaw = raw.runOptions ?? {};
         config.buildOptions = Object.assign(new BuildOptions(), raw.buildOptions ?? {});
         config.buildOptions.cmd =
@@ -58,6 +59,7 @@ export function loadConfig(CONFIG_PATH, warn = false) {
         config.buildOptions.args = Array.isArray(config.buildOptions.args)
             ? config.buildOptions.args.filter((item) => typeof item == "string")
             : [];
+        config.buildOptions.env = parseEnvValue(raw.buildOptions?.env, configDir, "$.buildOptions.env");
         config.buildOptions.target =
             typeof config.buildOptions.target == "string" &&
                 config.buildOptions.target.length
@@ -99,8 +101,35 @@ export function loadConfig(CONFIG_PATH, warn = false) {
                     ? legacyRun
                     : runtime.cmd;
         runtime.cmd = cmd;
+        runtime.browser =
+            runtimeRaw && typeof runtimeRaw.browser == "string"
+                ? runtimeRaw.browser
+                : "";
         config.runOptions.runtime = runtime;
-        config.modes = parseModes(raw.modes);
+        config.runOptions.env = parseEnvValue(runOptionsRaw.env, configDir, "$.runOptions.env");
+        const fuzzRaw = raw.fuzz ?? {};
+        config.fuzz = Object.assign(new FuzzConfig(), fuzzRaw);
+        config.fuzz.input = Array.isArray(config.fuzz.input)
+            ? config.fuzz.input.filter((item) => typeof item == "string")
+            : typeof fuzzRaw.input == "string"
+                ? [fuzzRaw.input]
+                : new FuzzConfig().input;
+        config.fuzz.runs = normalizePositiveNumber(config.fuzz.runs, 1000);
+        config.fuzz.seed = normalizeNonNegativeNumber(config.fuzz.seed, 1337);
+        config.fuzz.maxInputBytes = normalizePositiveNumber(config.fuzz.maxInputBytes, 4096);
+        config.fuzz.target =
+            typeof config.fuzz.target == "string" && config.fuzz.target.length
+                ? config.fuzz.target
+                : "bindings";
+        config.fuzz.corpusDir =
+            typeof config.fuzz.corpusDir == "string" && config.fuzz.corpusDir.length
+                ? config.fuzz.corpusDir
+                : "./.as-test/fuzz/corpus";
+        config.fuzz.crashDir =
+            typeof config.fuzz.crashDir == "string" && config.fuzz.crashDir.length
+                ? config.fuzz.crashDir
+                : "./.as-test/crashes";
+        config.modes = parseModes(raw.modes, configDir);
         return config;
     }
 }
@@ -116,14 +145,24 @@ const TOP_LEVEL_KEYS = new Set([
     "coverage",
     "env",
     "buildOptions",
+    "fuzz",
     "modes",
     "runOptions",
 ]);
-const BUILD_OPTION_KEYS = new Set(["cmd", "args", "target"]);
-const RUN_OPTION_KEYS = new Set(["runtime", "reporter", "run"]); // includes legacy "run"
-const RUNTIME_OPTION_KEYS = new Set(["cmd", "run"]); // includes legacy "run"
+const BUILD_OPTION_KEYS = new Set(["cmd", "args", "target", "env"]);
+const RUN_OPTION_KEYS = new Set(["runtime", "reporter", "run", "env"]); // includes legacy "run"
+const RUNTIME_OPTION_KEYS = new Set(["cmd", "run", "browser"]); // includes legacy "run"
 const REPORTER_OPTION_KEYS = new Set(["name", "options", "outDir", "outFile"]);
 const OUTPUT_OPTION_KEYS = new Set(["build", "logs", "coverage", "snapshots"]);
+const FUZZ_OPTION_KEYS = new Set([
+    "input",
+    "runs",
+    "seed",
+    "maxInputBytes",
+    "target",
+    "corpusDir",
+    "crashDir",
+]);
 const MODE_KEYS = new Set([
     "outDir",
     "logs",
@@ -149,6 +188,7 @@ function validateConfig(raw, configPath) {
     validateCoverageField(raw, "coverage", "$", issues);
     validateEnvField(raw, "env", "$", issues);
     validateBuildOptionsField(raw, "buildOptions", "$", issues);
+    validateFuzzField(raw, "fuzz", "$", issues);
     validateRunOptionsField(raw, "runOptions", "$", issues);
     validateModesField(raw, "modes", "$", issues);
     if (!issues.length)
@@ -279,7 +319,7 @@ function validateCoverageValue(value, path, issues) {
         issues.push({
             path,
             message: "must be a boolean or object",
-            fix: 'use true/false or { "enabled": true, "includeSpecs": false }',
+            fix: 'use true/false or { "enabled": true, "includeSpecs": false, "include": ["assembly/**/*.ts"], "exclude": ["assembly/__tests__/**/*.spec.ts"] }',
         });
         return;
     }
@@ -298,16 +338,72 @@ function validateCoverageValue(value, path, issues) {
             fix: "set to true or false",
         });
     }
+    validateStringArrayField(obj, "include", path, issues);
+    validateStringArrayField(obj, "exclude", path, issues);
+}
+function validateStringArrayField(raw, key, pathPrefix, issues) {
+    if (!(key in raw) || raw[key] == undefined)
+        return;
+    const value = raw[key];
+    if (!Array.isArray(value)) {
+        issues.push({
+            path: `${pathPrefix}.${key}`,
+            message: "must be an array of strings",
+            fix: `set "${key}" to an array of glob patterns`,
+        });
+        return;
+    }
+    for (let i = 0; i < value.length; i++) {
+        if (typeof value[i] == "string" && value[i].length)
+            continue;
+        issues.push({
+            path: `${pathPrefix}.${key}[${i}]`,
+            message: "must be a non-empty string",
+            fix: "remove invalid entries or replace them with valid glob strings",
+        });
+    }
 }
 function validateEnvField(raw, key, pathPrefix, issues) {
     if (!(key in raw) || raw[key] == undefined)
         return;
     const value = raw[key];
-    if (!value || typeof value != "object" || Array.isArray(value)) {
+    if (typeof value == "string") {
+        if (!value.length) {
+            issues.push({
+                path: `${pathPrefix}.${key}`,
+                message: "must not be an empty string",
+                fix: 'use a .env file path like "./secrets/.env"',
+            });
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            if (typeof item != "string" || !item.length) {
+                issues.push({
+                    path: `${pathPrefix}.${key}[${i}]`,
+                    message: "must be a non-empty string",
+                    fix: 'use entries like "FOO=1"',
+                });
+                continue;
+            }
+            const separator = item.indexOf("=");
+            if (separator <= 0) {
+                issues.push({
+                    path: `${pathPrefix}.${key}[${i}]`,
+                    message: 'must use "KEY=value" format',
+                    fix: 'example: "FOO=1"',
+                });
+            }
+        }
+        return;
+    }
+    if (!value || typeof value != "object") {
         issues.push({
             path: `${pathPrefix}.${key}`,
-            message: "must be an object of string values",
-            fix: 'example: "env": { "MY_FLAG": "1" }',
+            message: "must be a .env file path, array of KEY=value strings, or object of string values",
+            fix: 'example: "env": "./secrets/.env" or ["MY_FLAG=1"] or { "MY_FLAG": "1" }',
         });
         return;
     }
@@ -354,17 +450,20 @@ function validateBuildOptionsField(raw, key, pathPrefix, issues) {
             issues.push({
                 path: `${pathPrefix}.${key}.target`,
                 message: "must be a string",
-                fix: 'set to "wasi" or "bindings"',
+                fix: 'set to "wasi", "bindings", or "web"',
             });
         }
-        else if (obj.target != "wasi" && obj.target != "bindings") {
+        else if (obj.target != "wasi" &&
+            obj.target != "bindings" &&
+            obj.target != "web") {
             issues.push({
                 path: `${pathPrefix}.${key}.target`,
-                message: `must be "wasi" or "bindings"`,
+                message: `must be "wasi", "bindings", or "web"`,
                 fix: `received "${obj.target}"`,
             });
         }
     }
+    validateEnvField(obj, "env", `${pathPrefix}.${key}`, issues);
 }
 function validateRunOptionsField(raw, key, pathPrefix, issues) {
     if (!(key in raw) || raw[key] == undefined)
@@ -413,6 +512,13 @@ function validateRunOptionsField(raw, key, pathPrefix, issues) {
                     fix: 'legacy "run" should be a command string',
                 });
             }
+            if ("browser" in runtimeObj && typeof runtimeObj.browser != "string") {
+                issues.push({
+                    path: `${pathPrefix}.${key}.runtime.browser`,
+                    message: "must be a string",
+                    fix: 'set to "chrome", "chromium", "firefox", "webkit", or an executable path',
+                });
+            }
         }
     }
     if ("reporter" in obj && obj.reporter != undefined) {
@@ -463,6 +569,36 @@ function validateRunOptionsField(raw, key, pathPrefix, issues) {
             });
         }
     }
+    validateEnvField(obj, "env", `${pathPrefix}.${key}`, issues);
+}
+function validateFuzzField(raw, key, pathPrefix, issues) {
+    if (!(key in raw) || raw[key] == undefined)
+        return;
+    const value = raw[key];
+    if (!value || typeof value != "object" || Array.isArray(value)) {
+        issues.push({
+            path: `${pathPrefix}.${key}`,
+            message: "must be an object",
+            fix: 'example: "fuzz": { "input": ["./assembly/__fuzz__/*.fuzz.ts"], "runs": 1000 }',
+        });
+        return;
+    }
+    const obj = value;
+    validateUnknownKeys(obj, FUZZ_OPTION_KEYS, `${pathPrefix}.${key}`, issues);
+    validateInputField(obj, "input", `${pathPrefix}.${key}`, issues);
+    validateStringField(obj, "target", `${pathPrefix}.${key}`, issues);
+    validateStringField(obj, "corpusDir", `${pathPrefix}.${key}`, issues);
+    validateStringField(obj, "crashDir", `${pathPrefix}.${key}`, issues);
+    validateNumberField(obj, "runs", `${pathPrefix}.${key}`, issues, true);
+    validateNumberField(obj, "seed", `${pathPrefix}.${key}`, issues, false);
+    validateNumberField(obj, "maxInputBytes", `${pathPrefix}.${key}`, issues, true);
+    if ("target" in obj && obj.target != "bindings") {
+        issues.push({
+            path: `${pathPrefix}.${key}.target`,
+            message: 'must be "bindings"',
+            fix: 'set to "bindings"',
+        });
+    }
 }
 function validateModesField(raw, key, pathPrefix, issues) {
     if (!(key in raw) || raw[key] == undefined)
@@ -501,6 +637,33 @@ function validateModesField(raw, key, pathPrefix, issues) {
 function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item == "string");
 }
+function validateNumberField(raw, key, pathPrefix, issues, positiveOnly) {
+    if (!(key in raw) || raw[key] == undefined)
+        return;
+    if (typeof raw[key] != "number" || !Number.isFinite(raw[key])) {
+        issues.push({
+            path: `${pathPrefix}.${key}`,
+            message: "must be a finite number",
+            fix: `set "${key}" to a numeric value`,
+        });
+        return;
+    }
+    if (positiveOnly && Number(raw[key]) <= 0) {
+        issues.push({
+            path: `${pathPrefix}.${key}`,
+            message: "must be greater than zero",
+            fix: `set "${key}" to a positive integer`,
+        });
+        return;
+    }
+    if (!positiveOnly && Number(raw[key]) < 0) {
+        issues.push({
+            path: `${pathPrefix}.${key}`,
+            message: "must be zero or greater",
+            fix: `set "${key}" to a non-negative integer`,
+        });
+    }
+}
 function resolveClosestKey(value, keys) {
     let best = null;
     let bestDistance = Number.POSITIVE_INFINITY;
@@ -589,7 +752,7 @@ function applyOutputRoot(root, rawConfig, config) {
         config.snapshotDir = join(root, "snapshots");
     }
 }
-function parseModes(raw) {
+function parseModes(raw, configDir) {
     if (!raw || typeof raw != "object" || Array.isArray(raw))
         return {};
     const out = {};
@@ -629,6 +792,7 @@ function parseModes(raw) {
             if (Array.isArray(buildRaw.args)) {
                 build.args = buildRaw.args.filter((item) => typeof item == "string");
             }
+            build.env = parseEnvValue(buildRaw.env, configDir, `$.modes.${name}.buildOptions.env`);
             if (typeof buildRaw.target == "string" && buildRaw.target.length) {
                 build.target = buildRaw.target;
             }
@@ -649,6 +813,8 @@ function parseModes(raw) {
                 else {
                     runtime.cmd = "";
                 }
+                runtime.browser =
+                    typeof runtimeRaw.browser == "string" ? runtimeRaw.browser : "";
                 run.runtime = runtime;
             }
             if (typeof runRaw.reporter == "string") {
@@ -666,16 +832,10 @@ function parseModes(raw) {
                     typeof reporter.outFile == "string" ? reporter.outFile : "";
                 run.reporter = reporter;
             }
+            run.env = parseEnvValue(runRaw.env, configDir, `$.modes.${name}.runOptions.env`);
             mode.runOptions = run;
         }
-        if (modeRaw.env && typeof modeRaw.env == "object") {
-            const env = {};
-            for (const [key, val] of Object.entries(modeRaw.env)) {
-                if (typeof val == "string")
-                    env[key] = val;
-            }
-            mode.env = env;
-        }
+        mode.env = parseEnvValue(modeRaw.env, configDir, `$.modes.${name}.env`);
         out[name] = mode;
     }
     return out;
@@ -690,6 +850,87 @@ function parseEnvMap(raw) {
     }
     return env;
 }
+function parseEnvValue(raw, configDir, pathLabel) {
+    if (raw == undefined)
+        return {};
+    if (typeof raw == "string") {
+        return parseEnvFile(resolve(configDir, raw), pathLabel);
+    }
+    if (Array.isArray(raw)) {
+        return parseInlineEnvEntries(raw, pathLabel);
+    }
+    return parseEnvMap(raw);
+}
+function parseInlineEnvEntries(values, pathLabel) {
+    const env = {};
+    for (let i = 0; i < values.length; i++) {
+        const item = values[i];
+        if (typeof item != "string")
+            continue;
+        const separator = item.indexOf("=");
+        if (separator <= 0) {
+            throw new Error(`invalid config at ${pathLabel}\nenv entry at index ${i} must use KEY=value format`);
+        }
+        const key = item.slice(0, separator).trim();
+        const value = item.slice(separator + 1);
+        if (!key.length) {
+            throw new Error(`invalid config at ${pathLabel}\nenv entry at index ${i} must use a non-empty key`);
+        }
+        env[key] = value;
+    }
+    return env;
+}
+function parseEnvFile(envPath, pathLabel) {
+    if (!existsSync(envPath)) {
+        throw new Error(`invalid config at ${pathLabel}\nenv file not found: ${envPath}`);
+    }
+    const env = {};
+    const lines = readFileSync(envPath, "utf8").split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const rawLine = lines[i];
+        const line = rawLine.trim();
+        if (!line.length || line.startsWith("#"))
+            continue;
+        const normalized = line.startsWith("export ") ? line.slice(7).trim() : line;
+        const separator = normalized.indexOf("=");
+        if (separator <= 0) {
+            throw new Error(`invalid config at ${pathLabel}\ninvalid env line ${i + 1} in ${envPath}: expected KEY=value`);
+        }
+        const key = normalized.slice(0, separator).trim();
+        const value = normalized.slice(separator + 1).trim();
+        env[key] = unquoteEnvValue(value);
+    }
+    return env;
+}
+function unquoteEnvValue(value) {
+    if (value.length < 2)
+        return value;
+    const quote = value[0];
+    if ((quote != '"' && quote != "'") || value[value.length - 1] != quote) {
+        return value;
+    }
+    const inner = value.slice(1, -1);
+    if (quote == "'")
+        return inner;
+    return inner
+        .replace(/\\n/g, "\n")
+        .replace(/\\r/g, "\r")
+        .replace(/\\t/g, "\t")
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, "\\");
+}
+function normalizePositiveNumber(value, fallback) {
+    if (typeof value != "number" || !Number.isFinite(value) || value <= 0) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
+function normalizeNonNegativeNumber(value, fallback) {
+    if (typeof value != "number" || !Number.isFinite(value) || value < 0) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
 export function resolveModeNames(rawArgs) {
     const names = [];
     for (let i = 0; i < rawArgs.length; i++) {
@@ -718,12 +959,32 @@ function appendModeTokens(out, value) {
 }
 export function applyMode(config, modeName) {
     if (!modeName) {
+        const merged = Object.assign(new Config(), config);
+        merged.buildOptions = Object.assign(new BuildOptions(), config.buildOptions);
+        merged.runOptions = Object.assign(new RunOptions(), config.runOptions);
+        merged.runOptions.runtime = Object.assign(new Runtime(), config.runOptions.runtime);
+        merged.buildOptions.env = { ...config.buildOptions.env };
+        merged.runOptions.env = { ...config.runOptions.env };
+        merged.outDir = appendPathSegment(config.outDir, "default");
+        if (config.logs != "none") {
+            merged.logs = appendPathSegment(config.logs, "default");
+        }
+        if (config.coverageDir != "none") {
+            merged.coverageDir = appendPathSegment(config.coverageDir, "default");
+        }
+        merged.fuzz = Object.assign(new FuzzConfig(), config.fuzz);
+        merged.fuzz.crashDir = appendPathSegment(config.fuzz.crashDir, "default");
+        merged.fuzz.corpusDir = appendPathSegment(config.fuzz.corpusDir, "default");
+        const env = {
+            ...process.env,
+            ...config.env,
+        };
+        if (merged.runOptions.runtime.browser.length) {
+            env.BROWSER = merged.runOptions.runtime.browser;
+        }
         return {
-            config,
-            env: {
-                ...process.env,
-                ...config.env,
-            },
+            config: merged,
+            env,
         };
     }
     const mode = config.modes[modeName];
@@ -736,6 +997,8 @@ export function applyMode(config, modeName) {
     merged.buildOptions = Object.assign(new BuildOptions(), config.buildOptions);
     merged.runOptions = Object.assign(new RunOptions(), config.runOptions);
     merged.runOptions.runtime = Object.assign(new Runtime(), config.runOptions.runtime);
+    merged.buildOptions.env = { ...config.buildOptions.env };
+    merged.runOptions.env = { ...config.runOptions.env };
     if (mode.outDir)
         merged.outDir = mode.outDir;
     else
@@ -764,19 +1027,38 @@ export function applyMode(config, modeName) {
             ...mode.buildOptions.args,
         ];
     }
+    if (mode.buildOptions.env) {
+        merged.buildOptions.env = {
+            ...merged.buildOptions.env,
+            ...mode.buildOptions.env,
+        };
+    }
     if (mode.runOptions.runtime?.cmd) {
         merged.runOptions.runtime.cmd = mode.runOptions.runtime.cmd;
     }
+    if (mode.runOptions.runtime?.browser != undefined) {
+        merged.runOptions.runtime.browser = mode.runOptions.runtime.browser;
+    }
     if (mode.runOptions.reporter != undefined) {
         merged.runOptions.reporter = mode.runOptions.reporter;
     }
+    if (mode.runOptions.env) {
+        merged.runOptions.env = {
+            ...merged.runOptions.env,
+            ...mode.runOptions.env,
+        };
+    }
+    const env = {
+        ...process.env,
+        ...config.env,
+        ...mode.env,
+    };
+    if (merged.runOptions.runtime.browser.length) {
+        env.BROWSER = merged.runOptions.runtime.browser;
+    }
     return {
         config: merged,
-        env: {
-            ...process.env,
-            ...config.env,
-            ...mode.env,
-        },
+        env,
         modeName,
     };
 }

package/bin/wipc.js

@@ -0,0 +1,79 @@
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["OPEN"] = 0] = "OPEN";
+    MessageType[MessageType["CLOSE"] = 1] = "CLOSE";
+    MessageType[MessageType["CALL"] = 2] = "CALL";
+    MessageType[MessageType["DATA"] = 3] = "DATA";
+})(MessageType || (MessageType = {}));
+export class Channel {
+    constructor(input = process.stdin, output = process.stdout) {
+        this.input = input;
+        this.output = output;
+        this.buffer = Buffer.alloc(0);
+        this.input.on("data", (chunk) => this.onData(chunk));
+    }
+    send(type, payload) {
+        const body = payload ?? Buffer.alloc(0);
+        const header = Buffer.alloc(Channel.HEADER_SIZE);
+        Channel.MAGIC.copy(header, 0);
+        header.writeUInt8(type, 4);
+        header.writeUInt32LE(body.length, 5);
+        this.output.write(Buffer.concat([header, body]));
+    }
+    sendJSON(type, msg) {
+        const json = Buffer.from(JSON.stringify(msg), "utf8");
+        this.send(type, json);
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (true) {
+            if (this.buffer.length === 0)
+                return;
+            const idx = this.buffer.indexOf(Channel.MAGIC);
+            if (idx === -1) {
+                this.onPassthrough(this.buffer);
+                this.buffer = Buffer.alloc(0);
+                return;
+            }
+            if (idx > 0) {
+                this.onPassthrough(this.buffer.subarray(0, idx));
+                this.buffer = this.buffer.subarray(idx);
+            }
+            if (this.buffer.length < Channel.HEADER_SIZE)
+                return;
+            const type = this.buffer.readUInt8(4);
+            const length = this.buffer.readUInt32LE(5);
+            const frameSize = Channel.HEADER_SIZE + length;
+            if (this.buffer.length < frameSize)
+                return;
+            const payload = this.buffer.subarray(Channel.HEADER_SIZE, frameSize);
+            this.buffer = this.buffer.subarray(frameSize);
+            this.handleFrame(type, payload);
+        }
+    }
+    handleFrame(type, payload) {
+        switch (type) {
+            case MessageType.OPEN:
+                this.onOpen();
+                break;
+            case MessageType.CLOSE:
+                this.onClose();
+                break;
+            case MessageType.CALL:
+                this.onCall(JSON.parse(payload.toString("utf8")));
+                break;
+            case MessageType.DATA:
+                this.onDataMessage(payload);
+                break;
+            default:
+                throw new Error(`Unknown frame type: ${type}`);
+        }
+    }
+    onPassthrough(_data) { }
+    onOpen() { }
+    onClose() { }
+    onCall(_msg) { }
+    onDataMessage(_data) { }
+}
+Channel.MAGIC = Buffer.from("WIPC");
+Channel.HEADER_SIZE = 9;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -11,7 +11,8 @@
     "as-console": "^7.0.0",
     "chalk": "^5.6.2",
     "glob": "^13.0.3",
-    "typer-diff": "^1.1.1"
+    "typer-diff": "^1.1.1",
+    "wipc-js": "^0.1.1"
   },
   "devDependencies": {
     "@assemblyscript/wasi-shim": "^0.1.0",
@@ -20,11 +21,12 @@
     "as-sleep": "^0.0.2",
     "as-test": "./",
     "assemblyscript": "^0.28.9",
-    "assemblyscript-prettier": "^3.0.1",
-    "prettier": "3.6.2",
+    "assemblyscript-prettier": "^3.0.4",
+    "prettier": "3.8.1",
     "try-as": "^0.2.5",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.55.0"
+    "typescript-eslint": "^8.55.0",
+    "vitepress": "^1.6.4"
   },
   "bin": {
     "as-test": "./bin/index.js",
@@ -49,7 +51,7 @@
     "as-test.config.schema.json",
     "index.ts"
   ],
-  "homepage": "https://github.com/JairusSW/as-test#readme",
+  "homepage": "https://docs.jairus.dev/as-test",
   "keywords": [
     "assemblyscript",
     "testing",
@@ -63,16 +65,24 @@
   },
   "scripts": {
     "test": "node ./bin/index.js test",
+    "fuzz": "node ./bin/index.js fuzz",
+    "test:ci": "node ./bin/index.js test --tap --config ./as-test.ci.config.json",
     "test:examples": "npm --prefix ./examples run test",
+    "ci:act": "bash ./tools/act.sh push",
+    "ci:act:pr": "bash ./tools/act.sh pull_request",
+    "ci:act:tests": "act push -W .github/workflows/as-test.yml",
+    "ci:act:examples": "act push -W .github/workflows/examples.yml",
     "typecheck": "tsc -p cli --noEmit && tsc -p transform --noEmit",
     "lint": "eslint transform/src/**/*.ts tools/**/*.js eslint.config.js",
     "build:transform": "tsc -p ./transform",
     "build:cli": "tsc -p cli",
     "build:run": "npm run build:cli",
-    "prettier": "prettier -w .",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "format": "prettier -w .",
     "release:check": "npm run build:cli && npm run build:transform && npm run test && npm run test:examples && npm pack --dry-run --cache /tmp/as-test-npm-cache",
     "prepublishOnly": "npm run build:cli && npm run build:transform && npm run test"
   },
-  "type": "module",
-  "types": "assembly/index.ts"
+  "type": "module"
 }

package/transform/lib/coverage.js

@@ -15,8 +15,7 @@ const COVERAGE_IGNORED_CALLS = new Set([
     "unmockFn",
     "mockImport",
     "unmockImport",
-    "snapshotImport",
-    "restoreImport",
+    "snapshotFn",
 ]);
 const COVERAGE_IGNORED_BUILTINS = new Set([
     "alignof",