@elizaos/app-core 2.0.0-beta.2 → 2.0.11-beta.5

package/scripts/bun-riscv64/bun-patches/0014-disable-custom-inspector-dispatchers-on-riscv64.patch

@@ -0,0 +1,127 @@
+diff --git a/src/jsc/bindings/InspectorBunFrontendDevServerAgent.cpp b/src/jsc/bindings/InspectorBunFrontendDevServerAgent.cpp
+index 4cc5e4c..e9951b8 100644
+--- a/src/jsc/bindings/InspectorBunFrontendDevServerAgent.cpp
++++ b/src/jsc/bindings/InspectorBunFrontendDevServerAgent.cpp
+@@ -22,8 +22,13 @@ WTF_MAKE_TZONE_ALLOCATED_IMPL(InspectorBunFrontendDevServerAgent);
+ InspectorBunFrontendDevServerAgent::InspectorBunFrontendDevServerAgent(JSC::JSGlobalObject& globalObject)
+     : InspectorAgentBase("BunFrontendDevServer"_s)
+     // , m_globalobject(globalObject)
++#if defined(__riscv) && __riscv_xlen == 64
++    , m_backendDispatcher(nullptr)
++    , m_frontendDispatcher(nullptr)
++#else
+     , m_backendDispatcher(BunFrontendDevServerBackendDispatcher::create(globalObject.inspectorController().backendDispatcher(), this))
+     , m_frontendDispatcher(makeUnique<BunFrontendDevServerFrontendDispatcher>(const_cast<FrontendRouter&>(globalObject.inspectorController().frontendRouter())))
++#endif
+     , m_enabled(false)
+ {
+     UNUSED_PARAM(globalObject);
+diff --git a/src/jsc/bindings/InspectorBunFrontendDevServerAgent.h b/src/jsc/bindings/InspectorBunFrontendDevServerAgent.h
+index 2ba0e33..a9c04bf 100644
+--- a/src/jsc/bindings/InspectorBunFrontendDevServerAgent.h
++++ b/src/jsc/bindings/InspectorBunFrontendDevServerAgent.h
+@@ -46,7 +46,7 @@ public:
+ private:
+     // JSC::JSGlobalObject& m_globalobject;
+     std::unique_ptr<BunFrontendDevServerFrontendDispatcher> m_frontendDispatcher;
+-    Ref<BunFrontendDevServerBackendDispatcher> m_backendDispatcher;
++    RefPtr<BunFrontendDevServerBackendDispatcher> m_backendDispatcher;
+     bool m_enabled { false };
+ };
+ 
+diff --git a/src/jsc/bindings/InspectorHTTPServerAgent.cpp b/src/jsc/bindings/InspectorHTTPServerAgent.cpp
+index e1e1278..b53fdfa 100644
+--- a/src/jsc/bindings/InspectorHTTPServerAgent.cpp
++++ b/src/jsc/bindings/InspectorHTTPServerAgent.cpp
+@@ -25,10 +25,16 @@ void Bun__HTTPServerAgent__setEnabled(Inspector::InspectorHTTPServerAgent* agent
+ 
+ InspectorHTTPServerAgent::InspectorHTTPServerAgent(JSC::JSGlobalObject& globalObject)
+     : InspectorAgentBase("HTTPServer"_s)
++#if defined(__riscv) && __riscv_xlen == 64
++    , m_backendDispatcher(nullptr)
++    , m_frontendDispatcher(nullptr)
++#else
+     , m_backendDispatcher(HTTPServerBackendDispatcher::create(globalObject.inspectorController().backendDispatcher(), this))
+     , m_frontendDispatcher(makeUnique<HTTPServerFrontendDispatcher>(const_cast<FrontendRouter&>(globalObject.inspectorController().frontendRouter())))
++#endif
+     , m_enabled(false)
+ {
++    UNUSED_PARAM(globalObject);
+ }
+ 
+ InspectorHTTPServerAgent::~InspectorHTTPServerAgent()
+diff --git a/src/jsc/bindings/InspectorHTTPServerAgent.h b/src/jsc/bindings/InspectorHTTPServerAgent.h
+index 432a5fc..bfdd94b 100644
+--- a/src/jsc/bindings/InspectorHTTPServerAgent.h
++++ b/src/jsc/bindings/InspectorHTTPServerAgent.h
+@@ -52,7 +52,7 @@ public:
+ private:
+     WTF::HashMap<int, AnyServerPtr> m_serverIdToServerInstance;
+     std::unique_ptr<HTTPServerFrontendDispatcher> m_frontendDispatcher;
+-    Ref<HTTPServerBackendDispatcher> m_backendDispatcher;
++    RefPtr<HTTPServerBackendDispatcher> m_backendDispatcher;
+     bool m_enabled { false };
+ };
+ 
+diff --git a/src/jsc/bindings/InspectorLifecycleAgent.cpp b/src/jsc/bindings/InspectorLifecycleAgent.cpp
+index 761f7a6..1d8eb5d 100644
+--- a/src/jsc/bindings/InspectorLifecycleAgent.cpp
++++ b/src/jsc/bindings/InspectorLifecycleAgent.cpp
+@@ -51,8 +51,13 @@ void Bun__LifecycleAgentStopPreventingExit(Inspector::InspectorLifecycleAgent* a
+ InspectorLifecycleAgent::InspectorLifecycleAgent(JSC::JSGlobalObject& globalObject)
+     : InspectorAgentBase("LifecycleReporter"_s)
+     , m_globalObject(globalObject)
++#if defined(__riscv) && __riscv_xlen == 64
++    , m_backendDispatcher(nullptr)
++    , m_frontendDispatcher(nullptr)
++#else
+     , m_backendDispatcher(LifecycleReporterBackendDispatcher::create(m_globalObject.inspectorController().backendDispatcher(), this))
+     , m_frontendDispatcher(makeUnique<LifecycleReporterFrontendDispatcher>(const_cast<FrontendRouter&>(m_globalObject.inspectorController().frontendRouter())))
++#endif
+ {
+ }
+ 
+diff --git a/src/jsc/bindings/InspectorLifecycleAgent.h b/src/jsc/bindings/InspectorLifecycleAgent.h
+index d598e70..585a69d 100644
+--- a/src/jsc/bindings/InspectorLifecycleAgent.h
++++ b/src/jsc/bindings/InspectorLifecycleAgent.h
+@@ -43,7 +43,7 @@ public:
+ private:
+     JSC::JSGlobalObject& m_globalObject;
+     std::unique_ptr<LifecycleReporterFrontendDispatcher> m_frontendDispatcher;
+-    Ref<LifecycleReporterBackendDispatcher> m_backendDispatcher;
++    RefPtr<LifecycleReporterBackendDispatcher> m_backendDispatcher;
+     bool m_enabled { false };
+     bool m_preventingExit { false };
+ };
+diff --git a/src/jsc/bindings/InspectorTestReporterAgent.cpp b/src/jsc/bindings/InspectorTestReporterAgent.cpp
+index 968e5fa..30eacc2 100644
+--- a/src/jsc/bindings/InspectorTestReporterAgent.cpp
++++ b/src/jsc/bindings/InspectorTestReporterAgent.cpp
+@@ -118,8 +118,13 @@ void Bun__TestReporterAgentReportTestEnd(Inspector::InspectorTestReporterAgent*
+ InspectorTestReporterAgent::InspectorTestReporterAgent(JSC::JSGlobalObject& globalObject)
+     : InspectorAgentBase("TestReporter"_s)
+     , m_globalObject(globalObject)
++#if defined(__riscv) && __riscv_xlen == 64
++    , m_backendDispatcher(nullptr)
++    , m_frontendDispatcher(nullptr)
++#else
+     , m_backendDispatcher(TestReporterBackendDispatcher::create(m_globalObject.inspectorController().backendDispatcher(), this))
+     , m_frontendDispatcher(makeUnique<TestReporterFrontendDispatcher>(const_cast<FrontendRouter&>(m_globalObject.inspectorController().frontendRouter())))
++#endif
+ {
+ }
+ 
+diff --git a/src/jsc/bindings/InspectorTestReporterAgent.h b/src/jsc/bindings/InspectorTestReporterAgent.h
+index 9c165c1..8665928 100644
+--- a/src/jsc/bindings/InspectorTestReporterAgent.h
++++ b/src/jsc/bindings/InspectorTestReporterAgent.h
+@@ -41,7 +41,7 @@ public:
+ private:
+     JSC::JSGlobalObject& m_globalObject;
+     std::unique_ptr<TestReporterFrontendDispatcher> m_frontendDispatcher;
+-    Ref<TestReporterBackendDispatcher> m_backendDispatcher;
++    RefPtr<TestReporterBackendDispatcher> m_backendDispatcher;
+     bool m_enabled { false };
+ };
+ 

package/scripts/bun-riscv64/bun-patches/0015-disable-jsc-profiler-builtins-on-riscv64.patch

@@ -0,0 +1,75 @@
+diff --git a/src/jsc/modules/BunJSCModule.h b/src/jsc/modules/BunJSCModule.h
+index deb683b..61e54ce 100644
+--- a/src/jsc/modules/BunJSCModule.h
++++ b/src/jsc/modules/BunJSCModule.h
+@@ -437,6 +437,11 @@ JSC_DEFINE_HOST_FUNCTION(functionStartSamplingProfiler,
+     (JSC::JSGlobalObject * globalObject,
+         JSC::CallFrame* callFrame))
+ {
++#if defined(__riscv) && __riscv_xlen == 64
++    UNUSED_PARAM(globalObject);
++    UNUSED_PARAM(callFrame);
++    return JSC::JSValue::encode(jsUndefined());
++#else
+     auto& vm = JSC::getVM(globalObject);
+     JSC::SamplingProfiler& samplingProfiler = vm.ensureSamplingProfiler(WTF::Stopwatch::create());
+ 
+@@ -469,6 +474,7 @@ JSC_DEFINE_HOST_FUNCTION(functionStartSamplingProfiler,
+     samplingProfiler.noticeCurrentThreadAsJSCExecutionThread();
+     samplingProfiler.start();
+     return JSC::JSValue::encode(jsUndefined());
++#endif
+ }
+ 
+ JSC_DECLARE_HOST_FUNCTION(functionSamplingProfilerStackTraces);
+@@ -476,6 +482,10 @@ JSC_DEFINE_HOST_FUNCTION(functionSamplingProfilerStackTraces,
+     (JSC::JSGlobalObject * globalObject,
+         JSC::CallFrame*))
+ {
++#if defined(__riscv) && __riscv_xlen == 64
++    UNUSED_PARAM(globalObject);
++    return JSC::JSValue::encode(jsUndefined());
++#else
+     auto& vm = JSC::getVM(globalObject);
+     JSC::DeferTermination deferScope(vm);
+     auto scope = DECLARE_THROW_SCOPE(vm);
+@@ -489,6 +499,7 @@ JSC_DEFINE_HOST_FUNCTION(functionSamplingProfilerStackTraces,
+     JSC::EncodedJSValue result = JSC::JSValue::encode(JSONParse(globalObject, jsonString));
+     scope.releaseAssertNoException();
+     return result;
++#endif
+ }
+ 
+ JSC_DECLARE_HOST_FUNCTION(functionGetRandomSeed);
+@@ -582,7 +593,11 @@ JSC_DECLARE_HOST_FUNCTION(functionTotalCompileTime);
+ JSC_DEFINE_HOST_FUNCTION(functionTotalCompileTime,
+     (JSGlobalObject*, CallFrame*))
+ {
++#if defined(__riscv) && __riscv_xlen == 64
++    return JSValue::encode(jsNumber(0));
++#else
+     return JSValue::encode(jsNumber(JIT::totalCompileTime().milliseconds()));
++#endif
+ }
+ 
+ JSC_DECLARE_HOST_FUNCTION(functionGetProtectedObjects);
+@@ -660,6 +675,11 @@ JSC_DEFINE_HOST_FUNCTION(functionSetTimeZone, (JSGlobalObject * globalObject, Ca
+ 
+ JSC_DEFINE_HOST_FUNCTION(functionRunProfiler, (JSGlobalObject * globalObject, CallFrame* callFrame))
+ {
++#if defined(__riscv) && __riscv_xlen == 64
++    UNUSED_PARAM(globalObject);
++    UNUSED_PARAM(callFrame);
++    return JSValue::encode(jsUndefined());
++#else
+     auto& vm = JSC::getVM(globalObject);
+     JSC::SamplingProfiler& samplingProfiler = vm.ensureSamplingProfiler(WTF::Stopwatch::create());
+ 
+@@ -772,6 +792,7 @@ JSC_DEFINE_HOST_FUNCTION(functionRunProfiler, (JSGlobalObject * globalObject, Ca
+ 
+     JSValue result = report(vm, globalObject);
+     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
++#endif
+ }
+ 
+ JSC_DECLARE_HOST_FUNCTION(functionGenerateHeapSnapshotForDebugging);

package/scripts/bun-riscv64/bun-patches/0016-node-vm-disable-jit-cached-data-on-riscv64-c-loop.patch

@@ -0,0 +1,96 @@
+diff --git a/src/jsc/bindings/NodeVMScript.cpp b/src/jsc/bindings/NodeVMScript.cpp
+index d7cfa61..e18a30a 100644
+--- a/src/jsc/bindings/NodeVMScript.cpp
++++ b/src/jsc/bindings/NodeVMScript.cpp
+@@ -8,6 +8,7 @@
+ #include "JavaScriptCore/JSWeakMapInlines.h"
+ #include "JavaScriptCore/ProgramCodeBlock.h"
+ #include "JavaScriptCore/SourceCodeKey.h"
++#include "JavaScriptCore/Watchdog.h"
+ 
+ #include "NodeVMScriptFetcher.h"
+ #include "../vm/SigintWatcher.h"
+@@ -163,6 +164,10 @@ constructScript(JSGlobalObject* globalObject, CallFrame* callFrame, JSValue newT
+                 codeBlock = JSC::ProgramCodeBlock::create(vm, executable, unlinkedBlock, jsScope);
+                 RETURN_IF_EXCEPTION(scope, {});
+             }
++#if defined(__riscv) && __riscv_xlen == 64
++            UNUSED_PARAM(codeBlock);
++            script->cachedDataRejected(TriState::True);
++#else
+             JSC::CompilationResult compilationResult = JIT::compileSync(vm, codeBlock, JITCompilationEffort::JITCompilationCanFail);
+             if (compilationResult != JSC::CompilationResult::CompilationFailed) {
+                 executable->installCode(codeBlock);
+@@ -170,6 +175,7 @@ constructScript(JSGlobalObject* globalObject, CallFrame* callFrame, JSValue newT
+             } else {
+                 script->cachedDataRejected(TriState::True);
+             }
++#endif
+         }
+     } else if (produceCachedData) {
+         script->cacheBytecode();
+@@ -301,6 +307,15 @@ static bool checkForTermination(JSC::VM& vm, JSC::JSGlobalObject* globalObject,
+ 
+ void setupWatchdog(VM& vm, double timeout, double* oldTimeout, double* newTimeout)
+ {
++#if defined(__riscv) && __riscv_xlen == 64
++    UNUSED_PARAM(vm);
++    if (oldTimeout) {
++        *oldTimeout = timeout;
++    }
++    if (newTimeout) {
++        *newTimeout = timeout;
++    }
++#else
+     JSC::JSLockHolder locker(vm);
+     JSC::Watchdog& dog = vm.ensureWatchdog();
+     dog.enteredVM();
+@@ -320,6 +335,7 @@ void setupWatchdog(VM& vm, double timeout, double* oldTimeout, double* newTimeou
+     if (newTimeout) {
+         *newTimeout = timeout;
+     }
++#endif
+ }
+ 
+ static JSC::EncodedJSValue runInContext(NodeVMGlobalObject* globalObject, NodeVMScript* script, JSObject* contextifiedObject, JSValue optionsArg, bool allowStringInPlaceOfOptions = false)
+@@ -366,7 +382,9 @@ static JSC::EncodedJSValue runInContext(NodeVMGlobalObject* globalObject, NodeVM
+     RETURN_IF_EXCEPTION(scope, {});
+ 
+     if (options.timeout) {
++#if !(defined(__riscv) && __riscv_xlen == 64)
+         vm.watchdog()->setTimeLimit(WTF::Seconds::fromMilliseconds(*oldLimit));
++#endif
+     }
+ 
+     if (checkForTermination(vm, globalObject, scope, script, newLimit)) {
+@@ -429,7 +447,9 @@ JSC_DEFINE_HOST_FUNCTION(scriptRunInThisContext, (JSGlobalObject * globalObject,
+     }
+ 
+     if (options.timeout) {
++#if !(defined(__riscv) && __riscv_xlen == 64)
+         vm.watchdog()->setTimeLimit(WTF::Seconds::fromMilliseconds(*oldLimit));
++#endif
+     }
+ 
+     if (checkForTermination(vm, globalObject, scope, script, newLimit)) {
+diff --git a/src/jsc/bindings/NodeVMSourceTextModule.cpp b/src/jsc/bindings/NodeVMSourceTextModule.cpp
+index 2b83e97..2290f1e 100644
+--- a/src/jsc/bindings/NodeVMSourceTextModule.cpp
++++ b/src/jsc/bindings/NodeVMSourceTextModule.cpp
+@@ -140,12 +140,16 @@ NodeVMSourceTextModule* NodeVMSourceTextModule::create(VM& vm, JSGlobalObject* g
+             RETURN_IF_EXCEPTION(scope, nullptr);
+         }
+         if (codeBlock) {
++#if defined(__riscv) && __riscv_xlen == 64
++            UNUSED_PARAM(codeBlock);
++#else
+             CompilationResult compilationResult = JIT::compileSync(vm, codeBlock, JITCompilationEffort::JITCompilationCanFail);
+             RETURN_IF_EXCEPTION(scope, nullptr);
+             if (compilationResult != CompilationResult::CompilationFailed) {
+                 executable->installCode(codeBlock);
+                 return ptr;
+             }
++#endif
+         }
+     }
+ 

package/scripts/bun-riscv64/bun-patches/0017-disable-performance-domjit-signature-on-riscv64-c-loop.patch

@@ -0,0 +1,34 @@
+diff --git a/src/jsc/bindings/webcore/JSPerformance.cpp b/src/jsc/bindings/webcore/JSPerformance.cpp
+index 4aed2e5..71fff93 100644
+--- a/src/jsc/bindings/webcore/JSPerformance.cpp
++++ b/src/jsc/bindings/webcore/JSPerformance.cpp
+@@ -267,11 +267,16 @@ size_t JSPerformance::estimatedSize(JSCell* cell, VM& vm)
+ void JSPerformance::finishCreation(VM& vm)
+ {
+     Base::finishCreation(vm);
++#if defined(__riscv) && __riscv_xlen == 64
++    const JSC::DOMJIT::Signature* DOMJITSignatureForPerformanceNow = nullptr;
++#else
+     static const JSC::DOMJIT::Signature DOMJITSignatureForPerformanceNow(
+         functionPerformanceNowWithoutTypeCheck,
+         JSPerformance::info(),
+         JSC::DOMJIT::Effect::forWriteKinds(DFG::AbstractHeapKind::SideState),
+         SpecDoubleReal);
++    const JSC::DOMJIT::Signature* DOMJITSignatureForPerformanceNowPtr = &DOMJITSignatureForPerformanceNow;
++#endif
+ 
+     JSFunction* now = JSFunction::create(
+         vm,
+@@ -279,7 +284,11 @@ void JSPerformance::finishCreation(VM& vm)
+         0,
+         String("now"_s),
+         functionPerformanceNow, ImplementationVisibility::Public, NoIntrinsic, functionPerformanceNow,
+-        &DOMJITSignatureForPerformanceNow);
++#if defined(__riscv) && __riscv_xlen == 64
++        DOMJITSignatureForPerformanceNow);
++#else
++        DOMJITSignatureForPerformanceNowPtr);
++#endif
+     this->putDirect(vm, JSC::Identifier::fromString(vm, "now"_s), now, 0);
+ 
+     this->putDirect(

package/scripts/bun-riscv64/bun-patches/0018-fix-serialized-script-identifier-big-endian-path.patch

@@ -0,0 +1,19 @@
+diff --git a/src/jsc/bindings/webcore/SerializedScriptValue.cpp b/src/jsc/bindings/webcore/SerializedScriptValue.cpp
+index f1e72f3..ff7a363 100644
+--- a/src/jsc/bindings/webcore/SerializedScriptValue.cpp
++++ b/src/jsc/bindings/webcore/SerializedScriptValue.cpp
+@@ -3432,12 +3432,13 @@ private:
+         ptr += length * sizeof(char16_t);
+ #else
+         std::span<char16_t> characters;
+-        str = String::createUninitialized(length, characters);
++        String identifierString = String::createUninitialized(length, characters);
+         for (unsigned i = 0; i < length; ++i) {
+             uint16_t c;
+             readLittleEndian(ptr, end, c);
+             characters[i] = c;
+         }
++        str = Identifier::fromString(vm, identifierString);
+ #endif
+         return true;
+     }

package/scripts/bun-riscv64/bun-patches/0019-add-wtf-timer-fire-bridge-for-c-loop.patch

@@ -0,0 +1,24 @@
+diff --git a/src/jsc/bindings/wtf-bindings.cpp b/src/jsc/bindings/wtf-bindings.cpp
+index 0d4968f..3b6b202 100644
+--- a/src/jsc/bindings/wtf-bindings.cpp
++++ b/src/jsc/bindings/wtf-bindings.cpp
+@@ -3,6 +3,7 @@
+ #include <wtf/StackBounds.h>
+ #include <wtf/StackCheck.h>
+ #include <wtf/StackTrace.h>
++#include <wtf/RunLoop.h>
+ #include <wtf/dtoa.h>
+ #include <wtf/NumberOfCores.h>
+ #include <atomic>
+@@ -279,6 +280,11 @@ extern "C" void WTF__DumpStackTrace(void** stack, size_t stack_count)
+     WTFPrintBacktrace({ stack, stack_count });
+ }
+ 
++extern "C" void WTFTimer__fire(WTF::RunLoop::TimerBase* timer)
++{
++    timer->fired();
++}
++
+ extern "C" int WTF__numberOfProcessorCores()
+ {
+     return WTF::numberOfProcessorCores();

package/scripts/bun-riscv64/bun-patches/0020-run-riscv64-smoke-test-under-qemu.patch

@@ -0,0 +1,13 @@
+diff --git a/scripts/build/bun.ts b/scripts/build/bun.ts
+index a85fd4e..94ce55d 100644
+--- a/scripts/build/bun.ts
++++ b/scripts/build/bun.ts
+@@ -654,6 +654,8 @@ function emitSmokeTest(n: Ninja, cfg: Config, exe: string, exeName: string): voi
+   if (cfg.linux && cfg.asan) {
+     const arch = cfg.x64 ? "x86_64" : "aarch64";
+     testCmd = `${envWrap} setarch ${arch} -R ${exe} --revision || ${envWrap} ${exe} --revision`;
++  } else if (cfg.riscv64) {
++    testCmd = `${envWrap} qemu-riscv64-static -L /sysroot ${exe} --revision`;
+   } else if (cfg.windows) {
+     // Windows: no setarch, no env wrapper syntax differences matter for
+     // this simple case. cmd /c handles the pipe.

package/scripts/bun-riscv64/bun-patches/0021-fix-riscv64-linux-open-flags.patch

@@ -0,0 +1,25 @@
+diff --git a/src/sys/sys.zig b/src/sys/sys.zig
+index 3de403f..3067d8d 100644
+--- a/src/sys/sys.zig
++++ b/src/sys/sys.zig
+@@ -125,8 +125,9 @@ pub const O = switch (Environment.os) {
+ 
+         pub const toPacked = toPackedO;
+     },
+-    .linux, .wasm => switch (Environment.isX86) {
+-        true => struct {
++    .linux, .wasm => switch (builtin.target.cpu.arch) {
++        // x86 and riscv64 both use asm-generic-compatible Linux open flags.
++        .x86, .x86_64, .riscv64 => struct {
+             pub const RDONLY = 0x0000;
+             pub const WRONLY = 0x0001;
+             pub const RDWR = 0x0002;
+@@ -154,7 +155,7 @@ pub const O = switch (Environment.os) {
+ 
+             pub const toPacked = toPackedO;
+         },
+-        false => struct {
++        else => struct {
+             pub const RDONLY = 0x0000;
+             pub const WRONLY = 0x0001;
+             pub const RDWR = 0x0002;

package/scripts/bun-riscv64/bun-patches/0022-zlib-riscv64-generic-kernels.patch

@@ -0,0 +1,25 @@
+Subject: [PATCH] zlib: generic-only kernels for riscv64 (no SIMD table)
+
+bun-v1.3.14's zlib.ts selects per-arch zlib-ng SIMD kernels and throws
+for arches without a table. riscv64 has no RVV kernels wired up here, so
+build the portable generic C fallbacks (WITH_ALL_FALLBACKS) like a
+no-SIMD target. Required for --arch=riscv64 configure to succeed.
+
+diff --git a/scripts/build/deps/zlib.ts b/scripts/build/deps/zlib.ts
+index 2ee3470..d05a4f4 100644
+--- a/scripts/build/deps/zlib.ts
++++ b/scripts/build/deps/zlib.ts
+@@ -203,6 +203,13 @@ export const zlib: Dependency = {
+       }
+       sources.push(...GENERIC.map(s => `arch/generic/${s}.c`));
+       sources.push("arch/arm/arm_features.c");
++    } else if (cfg.riscv64) {
++      // No RVV SIMD kernels are wired up here; build the portable generic C
++      // fallbacks only (zlib-ng selects them via WITH_ALL_FALLBACKS).
++      kernels = [];
++      archDir = "generic";
++      defines.WITH_ALL_FALLBACKS = true;
++      sources.push(...GENERIC.map(s => `arch/generic/${s}.c`));
+     } else {
+       throw new Error(`zlib: no SIMD kernel table for arch ${cfg.arch}`);
+     }

package/scripts/bun-riscv64/bun-patches/README.md

@@ -0,0 +1,127 @@
+# Bun riscv64 patches
+
+This directory holds the Bun-side patches that have to land on top of
+`oven-sh/bun @ ${BUN_TAG}` (see `../bun-version.json:bun.tag`) so the
+build system accepts `riscv64-linux-musl` as a target.
+
+`build.sh` applies every `*.patch` in this directory **in lexical order**
+via `git am --3way` inside the Bun clone.
+
+## Why these are needed
+
+Bun's TypeScript build driver explicitly types its `Arch` as
+`"x64" | "aarch64"` (`scripts/build/config.ts`). Every codepath downstream
+of that — flag selection, CMake processor name, Rust target triple
+derivation, dependency build configs — branches on those two values. We
+need a small series of patches to:
+
+### Required patch areas
+
+1. **`scripts/build/config.ts`**
+   - Extend `Arch = "x64" | "aarch64"` → `Arch = "x64" | "aarch64" | "riscv64"`.
+   - In `detectHost()`, accept `arch === 'riscv64'`. (We only run the
+     build driver under cross-compile from an x86_64 host, so this is
+     mostly defensive — but the resolveConfig path goes through detectHost
+     for build-time host introspection too.)
+   - Add `cfg.riscv64: boolean` to the Config interface so dep configs
+     can switch on it ergonomically.
+
+2. **`scripts/build/flags.ts`**
+   - In `cpuTargetFlags`, add a `riscv64` entry that emits
+     `-march=rv64gc -mabi=lp64d`. (Match what the Docker wrappers already
+     pass — defense in depth, since `cpuTargetFlags` is applied late and
+     overrides the wrapper's defaults if the wrapper-supplied flags get
+     filtered out anywhere.)
+
+3. **`scripts/build/rust.ts`**
+   - `allRustTargets` already covers riscv64gc-unknown-linux-musl as a
+     Tier-2 prebuilt-std target, but verify the host→rust-triple mapping
+     emits it when `cfg.riscv64` is true.
+
+4. **`scripts/build/deps/webkit.ts`**
+   - The prebuilt-tarball URL constructor maps `arch` to `"amd64" | "arm64"`
+     only. For riscv64, force `cfg.webkit === "local"` (Bun's WEBKIT_PATH
+     env-var path) and disable the prebuilt branch — there is no upstream
+     `oven-sh/WebKit` tarball for riscv64 and there never will be unless
+     they publish one. `build.sh` already exports `BUN_WEBKIT_PATH`
+     pointing at the freshly built `WebKitBuild/riscv64-Release/`, so the
+     local-mode path is the only one we need to reach.
+
+5. **`scripts/build/deps/tinycc.ts`**
+   - The `oven-sh/tinycc` fork has no riscv64 backend. Gate the dep with
+     `enabled: cfg => cfg.tinycc && !cfg.riscv64`. The runtime config flag
+     already follows: bun:ffi's JIT-compile path becomes unavailable on
+     riscv64, but static FFI bindings still work. This is acceptable for
+     the Android agent runtime — `BUN_DISABLE_TINYCC=1` in build.sh's env
+     also enforces this through Bun's own toggle.
+
+6. **`scripts/build/bd.ts`** (or wherever `build:release` lives)
+   - Accept `--arch=riscv64 --abi=musl` and thread it through to the
+     cmake invocation. The `--webkit-path=...` flag should already work
+     unmodified; double-check it's not gated by arch.
+
+7. **`CMakeLists.txt`** (top-level)
+   - Wherever `CMAKE_SYSTEM_PROCESSOR` is normalized (search for
+     `aarch64` / `arm64` matches), add a `riscv64` branch that sets
+     `BUN_CPU=riscv64` and emits the correct `-march`/`-mabi`. If the
+     project gates entire compilation units behind `BUN_CPU` (some
+     vendored deps' CMakeLists do), add riscv64 to the allowlist.
+
+### Optional patch areas
+
+8. **`vendor/bun-uws/uSockets/CMakeLists.txt` (and other vendored libs)**
+   - Most vendored C/C++ deps will Just Work with riscv64 since they
+     consume `CMAKE_C_COMPILER` directly. Anything that grep'es
+     `CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64"` to enable assembly
+     fast-paths should add a `riscv64` branch that falls back to the
+     portable C implementation. Examples to check:
+     - mimalloc (`MI_ARCH` switch) — falls back fine.
+     - boringssl — Bun uses C fallbacks on non-x86 already.
+     - lol-html (Rust) — uses target features from cargo, no patches.
+
+## Realized patch series (against `bun-v1.3.14`)
+
+| File                                                | Touches                                       |
+|-----------------------------------------------------|-----------------------------------------------|
+| `0001-config-add-riscv64-arch.patch`                | `scripts/build/config.ts`                     |
+| `0002-flags-add-riscv64-march-mabi.patch`           | `scripts/build/flags.ts`                      |
+| `0003-zig-add-riscv64-target-triple-and-cpu.patch`  | `scripts/build/zig.ts`                        |
+| `0004-webkit-force-local-mode-on-riscv64.patch`     | `scripts/build/config.ts` + `deps/webkit.ts`  |
+| `0005-tinycc-disable-on-riscv64.patch`              | `scripts/build/deps/tinycc.ts`                |
+| `0006-build-add-riscv64-cli-validation.patch`       | `scripts/build.ts` (doc-only)                 |
+| `0007-deps-per-dep-riscv64-checks.patch`            | `scripts/build/deps/lolhtml.ts`               |
+| `0008-source-stabilize-riscv64-musl-build.patch`     | riscv64 source/build stabilization + LLVM strip override |
+| `0009-disable-wasm-streaming-hooks-for-c-loop.patch` | C_LOOP-only WebAssembly hook guards           |
+| `0010-disable-inspector-profiler-for-riscv64-c-loop.patch` | C_LOOP-only inspector/profiler stubs    |
+| `0011-process-arch-add-riscv64.patch`                | `process.arch` + node config riscv64 values   |
+| `0012-cpu-features-add-riscv64-fallback.patch`       | portable CPU feature fallback                 |
+| `0013-disable-console-inspector-hooks-for-riscv64-c-loop.patch` | C_LOOP-only console inspector guards |
+| `0014-disable-custom-inspector-dispatchers-on-riscv64.patch` | C_LOOP-only custom inspector dispatchers |
+| `0015-disable-jsc-profiler-builtins-on-riscv64.patch` | C_LOOP-only JSC profiler builtin guards      |
+| `0016-node-vm-disable-jit-cached-data-on-riscv64-c-loop.patch` | C_LOOP-only Node VM JIT/watchdog guards |
+| `0017-disable-performance-domjit-signature-on-riscv64-c-loop.patch` | C_LOOP-only performance DOMJIT guard |
+| `0018-fix-serialized-script-identifier-big-endian-path.patch` | explicit Identifier conversion for fallback string path |
+| `0019-add-wtf-timer-fire-bridge-for-c-loop.patch` | C_LOOP/local-WebKit `WTFTimer__fire` link bridge |
+| `0020-run-riscv64-smoke-test-under-qemu.patch` | run post-link `--revision` smoke through qemu |
+| `0021-fix-riscv64-linux-open-flags.patch` | use riscv64-compatible Linux open flags for resolver file/directory checks |
+
+Note on the original task brief: Bun 1.3.x removed the top-level
+`CMakeLists.txt` — the build is now fully driven by `scripts/build.ts`
+through ninja directly. There is no `cmake/` directory to patch, so
+"patch #7 CMakeLists.txt processor normalization" from the original
+brief was obsolete and is collapsed into `0007` (the per-dep audit).
+
+Likewise the `.cargo/config.toml` patch is unneeded: lol-html is the
+only cargo-built dep, and patch 0007 sets `rustTarget =
+riscv64gc-unknown-linux-${cfg.abi}` directly. `cargo` finds the
+cross-clang via the wrapper script in the Docker image's `/opt/cross/`.
+
+## Verifying
+
+```bash
+cd ../  # to bun-riscv64/
+./validate.sh
+```
+
+Runs `git apply --check` against a shallow clone of `oven-sh/bun @
+bun-v1.3.14`. See `../README.md` for output details.