No. You should not treat --emit=obj as a standalone library; the README explicitly says it is a relocatable program object, not a standalone library.

• The object contains undefined scr_* runtime references and requires a scr_runtime_abi_v2 marker, so matching runtime and ABI information are still required.
• External object consumption is experimental; the README requires --print=native-link-info to emit a versioned JSON recipe.
• That recipe records the target, main entry, exact @scriptc/runtime source pack, system libraries, FFI inputs, and ABI marker. The link command should not be reconstructed from hidden cache paths.
• For a self-contained archive, the README points to scriptc build --lib --profile ...; however, library-mode archives are diagnosed as unsupported for WASI targets.

C-driver or direct Apple-linker integration is possible, but only by following the complete recipe rather than treating the .o as an ordinary library.

Yes, provided that the program strictly follows the capability boundary of WASI Preview 1.

• The README requires Zig for WASI and other cross-target builds and uses bundled WASI libc to produce a WASI Preview 1 module.
• It explicitly lists async/await, Promises, generators, timers, stdin/readline events, and callback- and Promise-based filesystem APIs as supported capabilities.
• Network sockets/fetch, child processes, OS signals, and filesystem watching fail before linking with SC3002; your constraints avoid those limitations.
• The build requires SCRIPTC_CC=zigcc, SCRIPTC_TARGET=wasm32-wasi, and zig on PATH; zigcc is not a standalone executable.

If the tool also needs native FFI, sanitizers, or library-mode archives, those capabilities are diagnosed as unsupported for the WASI target.

Yes. coverage is specifically designed to support this decision.

• The README says scriptc coverage reports the percentage of a program that can compile statically and gives a coded diagnostic for every dynamic or unsupported site.
• Its example reports statements analyzed, compile statically, and fully static, allowing you to identify whether a dynamic remainder exists before building.
• The README also states that npm packages and any-typed code generally require --dynamic, so coverage can guide the choice between changing source code, accepting an embedded runtime, or abandoning the native path.
• Coverage does not prove full Node compatibility; the project remains experimental, and results depend on target-platform and runtime support.

Running coverage first is therefore the documented way to inspect code locations and diagnostics before choosing a static build or a quickjs-ng-backed dynamic build.

Yes, this is a good fit because the README explicitly supports producing standalone native executables, and those executables do not require Node at runtime.

• The compiler requires Node.js 24 or newer, but that is a build-time requirement rather than a deployment requirement.
• On macOS 15+ arm64, ordinary LLVM-tier executables use the bundled helper and precompiled runtime pack; clang acts only as the platform linker driver and does not compile the generated program or runtime C.
• Static builds contain a small native runtime but no Node or JavaScript engine. A typed CLI with little dynamic behavior is the best match for this path.
• The README demonstrates the standalone workflow with scriptc build hello.ts -o hello followed by ./hello.

However, API coverage and dynamic-language compatibility remain limited, so scriptc should not be treated as a complete Node.js replacement.

It depends, but the README provides a clear compatibility path if you accept an embedded QuickJS runtime.

• The README says npm packages and any-typed code should use --dynamic; this mode explicitly embeds quickjs-ng.
• The resulting executable does not read node_modules at runtime, which fits single-file CLI delivery.
• The trade-off is that the result is no longer a purely static native program: JavaScript execution comes from embedded QuickJS, so runtime size, performance, and compatibility differ from the static path.
• The project is experimental and does not promise that every npm package, native extension, or Node-specific behavior will work.

The README demonstrates this exact workflow by installing picocolors and running scriptc build cli.ts --dynamic -o cli, so this is the natural path for such a CLI.

It depends. The README demonstrates that some Node APIs can use the native runtime, but suitability depends on the service’s actual API boundary.

• The Use Node APIs example creates an HTTP service with node:http and builds it with scriptc build server.ts -o server.
• Project insights list support for filesystem, async operations, Promises, generators, timers, and stdin/readline, although coverage depends on the target platform.
• Static builds contain no Node or JavaScript engine; unsupported or non-statically-compilable code is reported diagnostically.
• Ordinary LLVM-tier executables still need a platform linker driver and SDK/sysroot. The precompiled runtime pack does not remove those build requirements.

A controlled HTTP service may therefore fit, while a service depending on the full Node ecosystem, dynamic loading, or unsupported APIs should not be migrated directly.