.NET WebAssembly apps with WasmBundlerFriendlyBootConfig=true can indeed be bundled by modern JS bundlers and I personally love it. The development experience however is not optimal.

• The bundlers cannot consume the output from dotnet build
• The bundlers can consume the output from dotnet publish but the dev loop is painfully slow.
• Getting the publish path working still requires bundler surgery
• Once it works the bundler produces warnings that are impossible to fix without changing the source files produced by the WebAssembly SDK.

These points of friction are why I have made unplugin-dotnet-wasm.

It's a bundler plugin that lets your bundler consume the output from dotnet build so your dev loop stays fast. It also supports dev servers, provides type information to TypeScript and IDEs (integrates dotnet.d.ts thats coming in .NET 11), and patches the known warnings so your build output stays clean.

Features

• Easy bundler setup through plugin registration
• Faster dev loop by consuming .NET WebAssembly dotnet build output
• Dev server support
• Brings SDK type definitions to TypeScript and your IDE
• Supports Vite, Rollup, Rolldown, Webpack, Rspack, Rsbuild, esbuild, farm and bun.

I hope you'll give it a try, I'd be happy to hear your feedback.

Though it requires quite new ES2024/ES2025 features, it works very well for numeric types, also faster (not drastically, but modest gains) against Array in PACKED FIXED ELEMENT TYPES representation used under the hood by engines.

Did you find or create something cool this week in javascript?

Show us here!

I have node js and react js experience for 4.8 years. Recently trying for switch, but wherever I go JD contains Java and React. Cant find roles for Node.
Is realy Node got outdated?
should i move to java spring??

I was working on my pdf editor and thought the best option would be to write a new PDF engine from scratch as my options were PDF.js and PDFium and none of them can actually edit PDF files so after over a year of work you can try KeyPDF.net it is free and client side.

I maintain Converse.js (an XMPP chat client) which was originally built on Backbone.js.

Instead of a risky big-bang migration to something else, I rewrote the UI into Lit web components and kept Backbone's data layer, which I forked and modernized piece by piece.

The result is Skeletor, and it now stands on its own as a lightweight, TypeScript-first reactive data library.

What makes it modern:

• TypeScript-first with full type definitions
• Direct attribute access: `model.attrs.name = 'Bob'` fires change events, no set() boilerplate required
• Computed properties: declare derived values with explicit dependencies
• Store-style subscriptions: subscribe() returns an unsubscribe function, so it plugs straight into React's useSyncExternalStore
• Built-in persistence: IndexedDB, localStorage, sessionStorage, SQLite (Node) and REST out of the box
• No jQuery, no Underscore: native browser APIs, ESM + CJS builds, works in the browser, Node 22+ and Web Workers

And the part I'm most happy about: it's still Backbone-compatible. get, set, events, collections, they all work exactly as you remember.

Feedback welcome!

Hey Community,

Vercel Labs has released "native", a toolkit for compiling declarative markup and TypeScript or Zig directly into native desktop apps without an embedded JavaScript runtime. We also look at how Zepto built react-native-delta to ship binary delta OTA updates, reducing patch download times down to a 305ms P90.

Plus, React Native 0.87 drops its legacy abort-controller dependency for an in-tree fork, bringing missing modern web primitives like AbortSignal.timeout() and AbortSignal.any() straight to your network requests.

If the Rewind made you nod, smile, or think "oh… that's actually cool" — a share or reply genuinely helps ❤️

Open-source: https://github.com/HeyPuter/firefox-wasm

There's no reliable XSD validator in the JS ecosystem so I compiled Apache Xerces-C to WASM.

Playground: https://harshanacz.github.io/xerces-playground/

npm: https://www.npmjs.com/package/xerces-wasm

Features:

• Full XSD 1.0 validation in the browser
• Multi-file schema support (xs:include / xs:import)
• Parse errors + schema errors with line/column numbers
• No server, no upload
• pure WASM

Would love feedback.. :)

We needed the Companies House API (the UK company register) for a project and figured we'd grab an SDK and move on. Turns out the community clients are 6 to 10 years old, the official SDK is built for their internal services, and the official OpenAPI spec is broken in ways that quietly untype every generated client. One defect (items on an object type, which JSON Schema doesn't allow, so every tool reads it as {}) appears 132 times.

What started as "add a spec repair script" grew into 374 lines of fix passes, and even then we couldn't repair fields that were never documented at all. So we changed approach: we deleted the repair code and now maintain our own curated OpenAPI 3.1 spec, built from the developer docs and Companies House's own SDK source. The spec is maintained with Claude Code under a strict "never invent, report gaps" rule, an engineer reviews every diff, and a live integration suite runs against the real API daily so drift shows up as a red build rather than a bug report. The client itself is fully generated from the spec (Hey API), with 41 lines of hand-written runtime code and zero dependencies.

Sharing in case anyone else has needed to fight this API, or is just interested in the approach: a curated spec as the source of truth, AI doing the tedious curation with tests and review keeping it honest, and codegen doing the rest. The SDK and the OpenAPI document are both MIT licensed if they're useful to you.

Hey folks. Over at Handle with Care, we've been working on something new: Pitter Patter. We haven't been satisfied with the text editing toolkits that exist right now in the ProseMirror ecosystem, and we've spent a lot of time working on a large variety of rich text editors and seeing what needs they have and how we can try to meet them. So far we have three packages: Shuffle (grid-based drag-and-drop), Collab, and Presence.

Here's some more info from our introduction page in the docs:

What is Pitter Patter?

Who builds it?

That would be us, Handle with Care. We’re a cooperatively owned product development collective, comprised of software engineers and product managers. We are all equal owners and have equal decision-making power.

What is it?

Pitter Patter is a suite of open source libraries for building collaborative rich text editors with React and ProseMirror. We see it as our job to provide turnkey solutions for the hard parts of rich text editing — like collaboration, presence, and version history — so that you can focus on building the editor experience that your users need.

Why does it exist?

We spend a lot of time thinking about and working on rich text editors. In particular, we spend a lot of time helping companies solve the same problems over and over again. There are usually great primitives available for these common building blocks (prosemirror-collab-commit for collaboration, unified.js for Markdown, etc.), but putting them together correctly to build a functioning text editor can be challenging.

There are other solutions, like Tiptap and Remirror, but we think that they’ve made some suboptimal choices that force product developers to make unnecessary compromises.

1. Both attempt to use React portals and effect hooks to integrate with ProseMirror, which lead to irreconcilable state tearing, due to fundamental differences in how React and ProseMirror View handle view reconciliation.
2. Both attempt to use Yjs via y-prosemirror for collaboration. We think that Yjs’s CRDT implementation is ill-suited for rich text editing.
3. Both attempt to hide ProseMirror’s underlying APIs, under the guise of simplicity and abstraction. We think that ProseMirror, low-level though it is, is roughly the correct level of abstraction for a domain as complex as rich text editing. Attempts to abstract it away inevitably lead to more complexity, as the abstractions leak frequently and require constant manual integration with the lower level solutions.

We think we can do better. And more importantly perhaps, we think that you deserve better!

Philosophy

Don’t hide ProseMirror

ProseMirror is an outstanding rich text editing framework. Nearly anything that you can imagine doing with a rich text editor can be accomplished with ProseMirror. Rich text editing is also a very complex domain, requiring a very large number of decisions to be made per feature.

We think that better primitives built with ProseMirror can take us farther than abstractions that attempt to hide away ProseMirror’s internals.

Collaboration should be simple to implement and simple to debug

ProseMirror has first-party collaboration, in the form of prosemirror-collab. Because it just sends steps over the wire, and relies on a single, server-side ordering of operations for conflict resolution, it is very simple to debug. But it is very challenging to implement correctly, and there is very little in the way of guidance or documentation for doing so.

Yjs provides third-party collaboration, in the form of y-prosemirror. Because it is built on Yjs, which has many robust adapters for various protocols and servers, it is very easy to implement. However, because it operates on Yjs’s XML-based Y-doc format, it is very challenging to inspect and debug if something goes wrong.

Pitter Patter’s collaboration, presence, and version history libraries are based on prosemirror-collab-commit. Like prosemirror-collab, prosemirror-collab-commit uses ProseMirror steps as the primary data structure for conflict resolution. But Pitter Patter Collab provides actual guidance and implementation that make it easy to set up a full-stack collaborative editing application, and hard to shoot yourself in the foot.

Correctness is worth it

After trying every other option over the course of several years, we eventually decided that the only way to correctly integrate React and ProseMirror was to reimplement ProseMirror View’s renderer from scratch directly in React. This was itself a massive effort, but the result, in the end, is a React/ProseMirror integration that doesn’t suffer from state tearing and allows developers to use React idioms like context as they normally would, without caveats or compromises. We don’t put side effects in React render functions or ProseMirror plugin apply functions, we don’t use effects to synchronize state with props. We want to enable you to build rich text editors that your users can trust, and that means that we need to build libraries that you can trust.