knitting 0.1.56 → 0.1.61

package/src/permission/compatibility.js

@@ -0,0 +1,239 @@
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const hasExplicit = (value, key) => value !== undefined && hasOwn(value, key);
+const hasNonEmptyArray = (value, key) => Array.isArray(value?.[key]) && value[key].length > 0;
+const explicitProtocolObject = (permission) => permission != null && typeof permission === "object"
+    ? permission
+    : undefined;
+const explicitNestedObject = (input, key) => {
+    const value = input?.[key];
+    return value != null && typeof value === "object"
+        ? value
+        : undefined;
+};
+const targetLabel = (target) => {
+    if (target.runtime !== "node") {
+        return `${target.runtime[0].toUpperCase()}${target.runtime.slice(1)}`;
+    }
+    return target.nodeMajor === undefined
+        ? "Node (version unknown)"
+        : `Node ${target.nodeMajor}`;
+};
+const nodeTargetUsesFfiTransport = (target) => target.runtime === "node" &&
+    target.nodeMajor !== undefined &&
+    target.nodeMajor >= 26 &&
+    target.nodeMajor % 2 === 0;
+const permissionCheck = (permission, level, reason) => ({
+    permission,
+    level,
+    reason,
+});
+const classifyRestriction = ({ target, permission, scoped, processNativeTransport = false, }) => {
+    const label = targetLabel(target);
+    const exact = (reason) => permissionCheck(permission, "exact", reason);
+    const coarse = (reason) => permissionCheck(permission, "coarse", reason);
+    const unsupported = (reason) => permissionCheck(permission, "unsupported", reason);
+    if (target.runtime === "bun") {
+        return unsupported("Bun process workers do not expose a matching runtime permission control.");
+    }
+    if (target.runtime === "deno") {
+        if (permission === "workers") {
+            return unsupported("Knitting does not currently configure a Deno worker-spawn restriction.");
+        }
+        if (permission === "wasi") {
+            return unsupported("Deno does not expose a matching Knitting WASI process permission.");
+        }
+        if (processNativeTransport &&
+            (permission === "ffi" || permission === "denyFfi")) {
+            return unsupported("Deno process workers require --allow-ffi for Knitting's shared-memory transport.");
+        }
+        return exact("Deno can represent this restriction with scoped runtime flags.");
+    }
+    if (permission === "read" || permission === "write") {
+        return exact(`${label} supports scoped filesystem allow rules.`);
+    }
+    if (permission === "run") {
+        return scoped
+            ? coarse(`${label} can only allow or deny all child processes, not an executable allow-list.`)
+            : exact(`${label} can deny all child processes.`);
+    }
+    if (permission === "workers") {
+        return exact(`${label} can deny worker creation.`);
+    }
+    if (permission === "wasi") {
+        return exact(`${label} can deny WASI.`);
+    }
+    if (permission === "net") {
+        if (target.nodeMajor === undefined) {
+            return unsupported("The Node version is unknown, so Knitting cannot prove that network denial is available.");
+        }
+        if (target.nodeMajor < 25) {
+            return unsupported(`${label} has no network permission control.`);
+        }
+        return scoped
+            ? coarse(`${label} --allow-net is all-or-nothing and cannot enforce a host allow-list.`)
+            : exact(`${label} denies network access when --allow-net is omitted.`);
+    }
+    if (permission === "node.allowAddons") {
+        if (nodeTargetUsesFfiTransport(target)) {
+            return exact(`${label} uses node:ffi rather than addons for Knitting's process transport.`);
+        }
+        return unsupported(`${label} process workers require addon permission for Knitting's shared-memory transport.`);
+    }
+    if (permission === "node.allowFfi") {
+        if (target.nodeMajor !== undefined &&
+            !nodeTargetUsesFfiTransport(target)) {
+            return exact(`${label} does not use node:ffi for Knitting's process transport.`);
+        }
+        return unsupported(`${label} process workers require node:ffi permission for Knitting's shared-memory transport.`);
+    }
+    if (processNativeTransport &&
+        (permission === "ffi" || permission === "denyFfi")) {
+        return unsupported(`${label} process workers require native-code permission for Knitting's shared-memory transport.`);
+    }
+    const unsupportedReasons = {
+        denyRead: `${label} has no filesystem deny-list control.`,
+        denyWrite: `${label} has no filesystem deny-list control.`,
+        denyNet: `${label} has no network deny-list control.`,
+        allowImport: `${label} has no import-host allow-list control.`,
+        env: `${label} has no environment-variable permission control.`,
+        denyEnv: `${label} has no environment-variable deny-list control.`,
+        denyRun: `${label} has no child-process deny-list control.`,
+        sys: `${label} has no system-information permission control.`,
+        denySys: `${label} has no system-information deny-list control.`,
+    };
+    return unsupported(unsupportedReasons[permission] ??
+        `${label} cannot represent this restriction.`);
+};
+export const classifyProcessPermissionCompatibility = ({ permission, resolved, target, }) => {
+    if (resolved?.enabled !== true ||
+        resolved.unsafe === true ||
+        permission === "unsafe" ||
+        permission === "off") {
+        return { target, checks: [] };
+    }
+    const input = explicitProtocolObject(permission);
+    const envInput = explicitNestedObject(input, "env");
+    const nodeInput = explicitNestedObject(input, "node");
+    const denoInput = explicitNestedObject(input, "deno");
+    const checks = [];
+    const add = (permissionName, explicit, options = {}) => {
+        checks.push({
+            ...classifyRestriction({
+                target,
+                permission: permissionName,
+                ...options,
+            }),
+            explicit,
+        });
+    };
+    if (!resolved.readAll) {
+        add("read", hasExplicit(input, "read"), {
+            scoped: resolved.read.length > 0,
+        });
+    }
+    if (!resolved.writeAll) {
+        add("write", hasExplicit(input, "write"), {
+            scoped: resolved.write.length > 0,
+        });
+    }
+    if (resolved.denyRead.length > 0) {
+        add("denyRead", hasNonEmptyArray(input, "denyRead"));
+    }
+    if (resolved.denyWrite.length > 0) {
+        add("denyWrite", hasNonEmptyArray(input, "denyWrite"));
+    }
+    if (!resolved.netAll) {
+        add("net", hasExplicit(input, "net"), {
+            scoped: resolved.net.length > 0,
+        });
+    }
+    if (resolved.denyNet.length > 0) {
+        add("denyNet", hasNonEmptyArray(input, "denyNet"));
+    }
+    if (!resolved.allowImportAll) {
+        add("allowImport", hasExplicit(input, "allowImport"), { scoped: resolved.allowImport.length > 0 });
+    }
+    if (!resolved.env.allowAll) {
+        add("env", hasExplicit(envInput, "allow"), {
+            scoped: resolved.env.allow.length > 0,
+        });
+    }
+    if (resolved.env.deny.length > 0) {
+        add("denyEnv", hasNonEmptyArray(envInput, "deny"));
+    }
+    if (!resolved.runAll) {
+        const explicitRun = hasExplicit(input, "run") ||
+            (target.runtime === "node" &&
+                hasExplicit(nodeInput, "allowChildProcess")) ||
+            (target.runtime === "deno" &&
+                hasExplicit(denoInput, "allowRun"));
+        add("run", explicitRun, { scoped: resolved.run.length > 0 });
+    }
+    if (resolved.denyRun.length > 0) {
+        add("denyRun", hasNonEmptyArray(input, "denyRun"));
+    }
+    if (!resolved.workers) {
+        const explicitWorkers = hasExplicit(input, "workers") ||
+            (target.runtime === "node" &&
+                hasExplicit(nodeInput, "allowWorker"));
+        add("workers", explicitWorkers);
+    }
+    if (!resolved.ffiAll) {
+        add("ffi", hasExplicit(input, "ffi"), {
+            scoped: resolved.ffi.length > 0,
+            processNativeTransport: true,
+        });
+    }
+    if (resolved.denyFfi.length > 0) {
+        add("denyFfi", hasNonEmptyArray(input, "denyFfi"), {
+            processNativeTransport: !resolved.ffiAll,
+        });
+    }
+    if (!resolved.sysAll) {
+        add("sys", hasExplicit(input, "sys"), {
+            scoped: resolved.sys.length > 0,
+        });
+    }
+    if (resolved.denySys.length > 0) {
+        add("denySys", hasNonEmptyArray(input, "denySys"));
+    }
+    if (!resolved.wasi) {
+        const explicitWasi = hasExplicit(input, "wasi") ||
+            (target.runtime === "node" &&
+                hasExplicit(nodeInput, "allowWasi"));
+        add("wasi", explicitWasi);
+    }
+    if (target.runtime === "node" && nodeInput !== undefined) {
+        if (hasOwn(nodeInput, "allowAddons") && nodeInput.allowAddons === false) {
+            add("node.allowAddons", true);
+        }
+        if (hasOwn(nodeInput, "allowFfi") && nodeInput.allowFfi === false) {
+            add("node.allowFfi", true);
+        }
+    }
+    return { target, checks };
+};
+const warningKeys = new Set();
+export const enforceProcessPermissionCompatibility = (report) => {
+    const incompatible = report.checks.filter((check) => check.level !== "exact");
+    const explicit = incompatible.filter((check) => check.explicit);
+    const label = targetLabel(report.target);
+    if (explicit.length > 0) {
+        const details = explicit
+            .map((check) => `permission.${check.permission} is ${check.level}: ${check.reason}`)
+            .join(" ");
+        throw new Error(`knitting: ${label} process workers cannot enforce the requested permission policy. ` +
+            `${details} Choose a runtime that can represent the restriction, add an OS sandbox, ` +
+            `or remove the restriction only if broader access is acceptable.`);
+    }
+    if (incompatible.length === 0)
+        return;
+    const names = [...new Set(incompatible.map((check) => check.permission))];
+    const warningKey = label;
+    if (warningKeys.has(warningKey))
+        return;
+    warningKeys.add(warningKey);
+    console.warn(`knitting: ${label} process workers cannot enforce every implicit strict ` +
+        `permission default (${names.join(", ")}). Explicit unsupported ` +
+        `restrictions fail closed; use an OS sandbox for hostile task code.`);
+};

package/src/permission/index.d.ts

@@ -1,2 +1,4 @@
+export { classifyProcessPermissionCompatibility, enforceProcessPermissionCompatibility, } from "./compatibility.js";
 export { resolvePermissionProtocol, toRuntimePermissionFlags, } from "./protocol.js";
+export type { PermissionCompatibilityCheck, PermissionCompatibilityLevel, ProcessPermissionCompatibilityReport, ProcessPermissionRuntime, ProcessPermissionTarget, } from "./compatibility.js";
 export type { PermissionPath, PermissionMode, PermissionLegacyMode, SysApiName, NodePermissionSettings, DenoPermissionSettings, PermissionEnvironment, PermissionProtocol, PermissionProtocolInput, ResolvedPermissionProtocol, } from "./protocol.js";

package/src/permission/index.js

@@ -1,2 +1,3 @@
+export { classifyProcessPermissionCompatibility, enforceProcessPermissionCompatibility, } from "./compatibility.js";
 export { resolvePermissionProtocol, toRuntimePermissionFlags, } from "./protocol.js";
 /* c8 ignore end */

package/src/permission/protocol.d.ts

@@ -3,6 +3,7 @@ type NodePermissionSettings = {
     allowWorker?: boolean;
     allowChildProcess?: boolean;
     allowAddons?: boolean;
+    allowFfi?: boolean;
     allowWasi?: boolean;
 };
 type DenoPermissionSettings = {

package/src/permission/protocol.js

@@ -1,9 +1,21 @@
-import { existsSync as existsSyncCompat, realpathSync as realpathSyncCompat, } from "node:fs";
-import { isAbsolute as pathIsAbsolute, relative as pathRelative, resolve as pathResolve, } from "node:path";
-import { fileURLToPath as fileURLToPathCompat } from "node:url";
-import { RUNTIME } from "../common/runtime.js";
+import { IS_BROWSER, RUNTIME } from "../common/runtime.js";
 import { toCanonicalPath as toSharedCanonicalPath } from "../common/path-canonical.js";
-import { getNodeProcess } from "../common/node-compat.js";
+import { getNodeBuiltinModule, getNodeProcess } from "../common/node-compat.js";
+const requireNodeModule = (specifier) => {
+    const module = getNodeBuiltinModule(specifier);
+    if (module === undefined) {
+        throw new Error(`${specifier} is not available in this runtime`);
+    }
+    return module;
+};
+const nodeFs = () => requireNodeModule("node:fs");
+const nodePath = () => requireNodeModule("node:path");
+const nodeUrl = () => requireNodeModule("node:url");
+const existsSyncCompat = (path) => nodeFs().existsSync(path);
+const pathIsAbsolute = (path) => nodePath().isAbsolute(path);
+const pathRelative = (from, to) => nodePath().relative(from, to);
+const pathResolve = (...segments) => nodePath().resolve(...segments);
+const fileURLToPathCompat = (url) => nodeUrl().fileURLToPath(url);
 const DEFAULT_ENV_FILE = ".env";
 const DEFAULT_DENO_LOCK_FILE = "deno.lock";
 const NODE_MODULES_DIR = "node_modules";
@@ -209,7 +221,10 @@ const toEnvFiles = (input, cwd, home) => {
             : [DEFAULT_ENV_FILE];
     return toUniquePathList(values, cwd, home);
 };
-const rawRealpathSync = realpathSyncCompat.native ?? realpathSyncCompat;
+const rawRealpathSync = (candidate) => {
+    const { realpathSync } = nodeFs();
+    return (realpathSync.native ?? realpathSync)(candidate);
+};
 const toCanonicalPath = (candidate) => {
     return toSharedCanonicalPath(candidate, {
         existsSync: existsSyncCompat,
@@ -276,26 +291,45 @@ const resolveNodePermissionActivationFlag = () => {
     }
     return "--permission";
 };
-const toNodeFlags = ({ read, readAll, write, writeAll, envFiles, node, }) => {
+const nodeSupportsNetworkPermission = () => {
+    try {
+        const raw = getNodeProcess()?.versions?.node;
+        const major = Number.parseInt(String(raw).split(".", 1)[0] ?? "", 10);
+        return Number.isInteger(major) && major >= 25;
+    }
+    catch {
+        return false;
+    }
+};
+const toNodeFlags = ({ read, readAll, write, writeAll, netAll, envFiles, node, }) => {
     const modelFlags = [];
     if (readAll) {
         modelFlags.push("--allow-fs-read=*");
     }
-    else if (read.length > 0) {
-        modelFlags.push(`--allow-fs-read=${read.join(",")}`);
+    else {
+        for (const path of read) {
+            modelFlags.push(`--allow-fs-read=${path}`);
+        }
     }
     if (writeAll) {
         modelFlags.push("--allow-fs-write=*");
     }
-    else if (write.length > 0) {
-        modelFlags.push(`--allow-fs-write=${write.join(",")}`);
+    else {
+        for (const path of write) {
+            modelFlags.push(`--allow-fs-write=${path}`);
+        }
     }
     if (node.allowWorker)
         modelFlags.push("--allow-worker");
     if (node.allowChildProcess)
         modelFlags.push("--allow-child-process");
+    if (netAll && nodeSupportsNetworkPermission()) {
+        modelFlags.push("--allow-net");
+    }
     if (node.allowAddons)
         modelFlags.push("--allow-addons");
+    if (node.allowFfi)
+        modelFlags.push("--allow-ffi");
     if (node.allowWasi)
         modelFlags.push("--allow-wasi");
     const flags = [];
@@ -402,6 +436,10 @@ export const resolvePermissionProtocol = ({ permission, modules, }) => {
     const input = normalizeProtocolInput(permission);
     if (!input)
         return undefined;
+    // Browsers have no filesystem, process, or runtime flags to police, and the
+    // strict default would otherwise reach for `node:path` and throw.
+    if (IS_BROWSER)
+        return undefined;
     const rawMode = input.mode;
     const mode = (rawMode === "unsafe" || rawMode === "off")
         ? "unsafe"
@@ -458,6 +496,7 @@ export const resolvePermissionProtocol = ({ permission, modules, }) => {
                 allowWorker: true,
                 allowChildProcess: true,
                 allowAddons: true,
+                allowFfi: true,
                 allowWasi: true,
                 flags: [],
             },
@@ -534,9 +573,7 @@ export const resolvePermissionProtocol = ({ permission, modules, }) => {
     const workers = hasOwn(input, "workers")
         ? input.workers === true
         : input.node?.allowWorker === true;
-    const ffiSource = hasOwn(input, "ffi")
-        ? input.ffi
-        : (input.node?.allowAddons === true ? true : false);
+    const ffiSource = hasOwn(input, "ffi") ? input.ffi : false;
     const ffiAll = ffiSource === true;
     const ffi = ffiAll ? [] : toUniquePathList(Array.isArray(ffiSource) ? ffiSource : undefined, cwd, home);
     const denyFfi = toUniquePathList(input.denyFfi, cwd, home);
@@ -552,7 +589,13 @@ export const resolvePermissionProtocol = ({ permission, modules, }) => {
     const nodeSettings = {
         allowWorker: workers,
         allowChildProcess: runAll || run.length > 0,
-        allowAddons: ffiAll || ffi.length > 0,
+        // Top-level `ffi` is the explicit cross-runtime native-code capability.
+        // Runtime-specific overrides stay independent so allowing addons does not
+        // silently grant unrestricted node:ffi access.
+        allowAddons: input.node?.allowAddons === true ||
+            ffiAll ||
+            ffi.length > 0,
+        allowFfi: input.node?.allowFfi === true || ffiAll || ffi.length > 0,
         allowWasi: wasi,
     };
     const denoSettings = {
@@ -604,6 +647,7 @@ export const resolvePermissionProtocol = ({ permission, modules, }) => {
                 readAll,
                 write: resolvedWrite,
                 writeAll,
+                netAll,
                 envFiles,
                 node: nodeSettings,
             }),

package/src/runtime/compiled-artifact.d.ts

@@ -0,0 +1,21 @@
+import type { CompiledWorkerCheck, CompiledWorkerOptions } from "../types.js";
+export declare const COMPILED_WORKER_FORMAT = "knitting-compiled-worker";
+export declare const COMPILED_WORKER_FORMAT_VERSION = 1;
+export declare const COMPILED_WORKER_PROTOCOL = "knitting-number-v1";
+export declare const COMPILED_WORKER_JSON_PROTOCOL = "knitting-json-v1";
+export declare const COMPILED_WORKER_EXTENSION = ".knt";
+export type CompiledWorkerTask = {
+    index: number;
+    exportName: string;
+};
+export type ArtifactInspection = CompiledWorkerCheck & {
+    artifactHref: string;
+    manifestHref: string;
+    taskEntries?: CompiledWorkerTask[];
+};
+export declare const defaultCompiledWorkerArtifact: (source: string | URL) => string;
+export declare const inspectCompiledWorkerArtifact: ({ source, options, requiredTasks, }: {
+    source: string | URL;
+    options?: CompiledWorkerOptions;
+    requiredTasks?: readonly string[];
+}) => ArtifactInspection;

package/src/runtime/compiled-artifact.js

@@ -0,0 +1,260 @@
+import { getNodeBuiltinModule, getNodeProcess } from "../common/node-compat.js";
+import { toModuleUrl } from "../common/module-url.js";
+export const COMPILED_WORKER_FORMAT = "knitting-compiled-worker";
+export const COMPILED_WORKER_FORMAT_VERSION = 1;
+export const COMPILED_WORKER_PROTOCOL = "knitting-number-v1";
+export const COMPILED_WORKER_JSON_PROTOCOL = "knitting-json-v1";
+export const COMPILED_WORKER_EXTENSION = ".knt";
+const deno = globalThis.Deno;
+const normalizeArch = (arch) => {
+    if (arch === "x86_64")
+        return "x64";
+    if (arch === "aarch64")
+        return "arm64";
+    return arch ?? "unknown";
+};
+const runtimeTarget = () => {
+    const process = getNodeProcess();
+    if (process !== undefined) {
+        return {
+            platform: process.platform ?? "unknown",
+            arch: normalizeArch(process.arch),
+        };
+    }
+    return {
+        platform: deno?.build?.os ?? "unknown",
+        arch: normalizeArch(deno?.build?.arch),
+    };
+};
+const normalizeSourceHref = (source) => source instanceof URL ? source.href : toModuleUrl(source);
+const resolveHref = (value, base) => {
+    try {
+        return new URL(value).href;
+    }
+    catch {
+        return new URL(value, base).href;
+    }
+};
+export const defaultCompiledWorkerArtifact = (source) => {
+    const url = new URL(normalizeSourceHref(source));
+    url.search = "";
+    url.hash = "";
+    url.pathname = url.pathname.replace(/\.[^./]+$/, "") +
+        COMPILED_WORKER_EXTENSION;
+    return url.href;
+};
+const artifactHrefs = (source, options = {}) => {
+    const sourceHref = normalizeSourceHref(source);
+    const artifactHref = options.artifact === undefined
+        ? defaultCompiledWorkerArtifact(sourceHref)
+        : resolveHref(options.artifact, sourceHref);
+    const manifestHref = options.manifest === undefined
+        ? artifactHref + ".json"
+        : resolveHref(options.manifest, artifactHref);
+    return { artifactHref, manifestHref };
+};
+const filePath = (href) => {
+    const converter = getNodeBuiltinModule("node:url")?.fileURLToPath;
+    if (converter !== undefined)
+        return converter(href);
+    const url = new URL(href);
+    if (url.protocol !== "file:") {
+        throw new Error("Compiled worker artifact must use file:, got " + url.protocol);
+    }
+    return decodeURIComponent(url.pathname);
+};
+const readTextFile = (path) => {
+    const fs = getNodeBuiltinModule("node:fs");
+    if (fs !== undefined)
+        return fs.readFileSync(path, "utf8");
+    if (deno?.readTextFileSync !== undefined)
+        return deno.readTextFileSync(path);
+    throw new Error("Synchronous filesystem access is unavailable");
+};
+const inspectExecutable = (path) => {
+    try {
+        const fs = getNodeBuiltinModule("node:fs");
+        if (fs !== undefined) {
+            const stat = fs.statSync(path);
+            if (!stat.isFile())
+                return "artifact is not a file";
+            if (runtimeTarget().platform !== "win32" && (stat.mode & 0o111) === 0) {
+                return "artifact is not executable";
+            }
+            return undefined;
+        }
+        if (deno?.statSync !== undefined) {
+            const stat = deno.statSync(path);
+            if (!stat.isFile)
+                return "artifact is not a file";
+            if (stat.mode !== null && (stat.mode & 0o111) === 0) {
+                return "artifact is not executable";
+            }
+            return undefined;
+        }
+        return "filesystem metadata is unavailable";
+    }
+    catch (error) {
+        const message = String(error?.message ?? error);
+        return "artifact is unavailable: " + message;
+    }
+};
+const compilerLabel = (compiler) => {
+    if (typeof compiler === "string" && compiler.length > 0)
+        return compiler;
+    if (compiler !== null && typeof compiler === "object" &&
+        typeof compiler.name === "string" &&
+        compiler.name.length > 0 &&
+        typeof compiler.version === "string") {
+        const value = compiler;
+        return (value.name + " " + value.version).trim();
+    }
+    return undefined;
+};
+export const inspectCompiledWorkerArtifact = ({ source, options, requiredTasks, }) => {
+    const sourceHref = normalizeSourceHref(source);
+    const { artifactHref, manifestHref } = artifactHrefs(sourceHref, options);
+    let artifact;
+    let manifest;
+    try {
+        artifact = filePath(artifactHref);
+        manifest = filePath(manifestHref);
+    }
+    catch (error) {
+        const message = String(error?.message ?? error);
+        return {
+            compiled: false,
+            artifact: artifactHref,
+            manifest: manifestHref,
+            artifactHref,
+            manifestHref,
+            reason: message,
+        };
+    }
+    const base = {
+        compiled: false,
+        artifact,
+        manifest,
+        artifactHref,
+        manifestHref,
+    };
+    const executableProblem = inspectExecutable(artifact);
+    if (executableProblem !== undefined) {
+        return { ...base, reason: executableProblem };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readTextFile(manifest));
+    }
+    catch (error) {
+        const message = String(error?.message ?? error);
+        return {
+            ...base,
+            reason: "manifest is unavailable or invalid: " + message,
+        };
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { ...base, reason: "manifest root must be an object" };
+    }
+    const workerManifest = parsed;
+    const compiler = compilerLabel(workerManifest.compiler);
+    const details = {
+        compiler,
+        protocol: typeof workerManifest.protocol === "string"
+            ? workerManifest.protocol
+            : undefined,
+    };
+    if (workerManifest.format !== COMPILED_WORKER_FORMAT ||
+        workerManifest.version !== COMPILED_WORKER_FORMAT_VERSION) {
+        return { ...base, ...details, reason: "unsupported manifest format" };
+    }
+    if (workerManifest.protocol !== COMPILED_WORKER_PROTOCOL &&
+        workerManifest.protocol !== COMPILED_WORKER_JSON_PROTOCOL) {
+        return { ...base, ...details, reason: "unsupported worker protocol" };
+    }
+    if (compiler === undefined) {
+        return { ...base, ...details, reason: "manifest compiler is invalid" };
+    }
+    const target = runtimeTarget();
+    if (workerManifest.target?.platform !== target.platform ||
+        normalizeArch(workerManifest.target?.arch) !== target.arch) {
+        return {
+            ...base,
+            ...details,
+            reason: "artifact target " +
+                (workerManifest.target?.platform ?? "unknown") + "/" +
+                (workerManifest.target?.arch ?? "unknown") + " does not match " +
+                target.platform + "/" + target.arch,
+        };
+    }
+    if (!Array.isArray(workerManifest.tasks) || workerManifest.tasks.length === 0) {
+        return { ...base, ...details, reason: "manifest has no tasks" };
+    }
+    const indices = new Set();
+    const taskNames = new Set();
+    for (const task of workerManifest.tasks) {
+        if (!Number.isSafeInteger(task?.index) || task.index < 0 ||
+            task.index > 0x7fff_ffff ||
+            typeof task.exportName !== "string" || task.exportName.length === 0 ||
+            indices.has(task.index) || taskNames.has(task.exportName)) {
+            return { ...base, ...details, reason: "manifest task table is invalid" };
+        }
+        indices.add(task.index);
+        taskNames.add(task.exportName);
+    }
+    if (typeof workerManifest.source !== "string" ||
+        workerManifest.source.length === 0) {
+        return { ...base, ...details, reason: "manifest source is invalid" };
+    }
+    let manifestSource;
+    try {
+        manifestSource = resolveHref(workerManifest.source.replace(/\\/g, "/"), artifactHref);
+    }
+    catch {
+        return { ...base, ...details, reason: "manifest source is invalid" };
+    }
+    if (manifestSource !== sourceHref) {
+        return {
+            ...base,
+            ...details,
+            tasks: [...taskNames],
+            reason: "manifest was built for a different task module",
+        };
+    }
+    if (Number.isFinite(workerManifest.sourceMtimeMs)) {
+        try {
+            const sourcePath = filePath(sourceHref);
+            const fs = getNodeBuiltinModule("node:fs");
+            const currentMtime = fs?.statSync(sourcePath).mtimeMs ??
+                deno?.statSync?.(sourcePath).mtime?.getTime();
+            if (currentMtime !== undefined &&
+                currentMtime > workerManifest.sourceMtimeMs + 0.5) {
+                return {
+                    ...base,
+                    ...details,
+                    tasks: [...taskNames],
+                    reason: "task module changed after the artifact was built",
+                };
+            }
+        }
+        catch {
+            return { ...base, ...details, reason: "task module is unavailable" };
+        }
+    }
+    const missing = requiredTasks?.filter((name) => !taskNames.has(name)) ?? [];
+    if (missing.length > 0) {
+        return {
+            ...base,
+            ...details,
+            tasks: [...taskNames],
+            reason: "compiled artifact is missing tasks: " + missing.join(", "),
+        };
+    }
+    return {
+        ...base,
+        ...details,
+        compiled: true,
+        tasks: [...taskNames],
+        taskEntries: workerManifest.tasks,
+    };
+};