Something perhaps tidier that you can already do now is use a handle hook that returns the desired JSON instead of whatever resolve() returns.

I'm not sure how we'd want __error.json (or, more likely, __error.js) to behave. I'm not clear on what its API should be, what the file should export, or what it would be passed. As for what the function returns, presumably it would be the same as other endpoint functions (i.e., an object with status, headers, body, etc.) and if it returned falsy, rendering would fall back to __error.svelte. But it's not clear what should be passed to this function.

The handle hook practically solves my 404 issue (thanks for pointing me to it!)
For my other issue (giving a 405 error when a wrong http method is used) it would be the easiest if there was a generic handle function like the handle hook in endpoints that receives the request before passing it along to the function corresponding to the http method, kinda like this:

export function get() {
    return {
        status: 200,
        body: { "hello": "world" }
    }
}

export async function handle({ request, resolve }) {
    // Try to resolve the request like normal with one of the functions corresponding to an http method
    const response = await resolve(request)

    // If it returns falsy, it means we haven't given the http method a function
    if (!response) {
        const error = { "error": "badmethod", "message": "Method Not Allowed" }
        const body = JSON.stringify(error)
        return {
            status: 405,
            body: body,
            headers: {
                'content-type': 'application/json; charset=utf-8',
                'Allow': 'GET, HEAD'
            }
        }
    }

    // Otherwise, return like normal
    return response
}

Looking through the sveltekit source, I think I might be able to make a pull request for this if this is acceptable.

EDIT:
Through testing I've also seen that HEAD requests must be handled manually in sveltekit, though I suppose that could also be easily fixed within the handle hook.

This might also be related to #1857

I have a very same feature request, but different use case and proposed solution.

Describe the problem

I have a complex API consumed by 3rd party programs. I'd like to communicate errors in JSON. So far, I do something like

export const get: RequestHandler = async ({ request, locals }) => {
  try {
    return { body: await getProductsByOwner(locals.ownerId) }
  } catch (e) {
    return { body: { error: e.message } }
  }
}

But it's very repetitive and verbose. I tried to catch the error in hooks.ts, but it doesn't work.

Describe the proposed solution

If handleError hook returns Response use this instead of default or custom error page.

Alternatives considered

Allow creating __error.js|ts endpoint, which would be used instead of __error.svelte if an error comes from endpoint rather than page. But this wouldn't cover 404 errors.

Endpoint would export one default function with the same parameters as handleError hook (error, event).

Importance

Nice to have

Nowadays SvelteKit returns 405s automatically (it wasn't possible at the time this issue was raised).

Related: #4477

This is basically implemented already — in newer versions of SvelteKit, errors will be turned into JSON if you request with the appropriate accept header — but #6497 finishes the job by making that the default with accept: */*.

See also #6499