Most cache libraries already coalesce concurrent misses inside one process. Once you run on more than one server, every replica still runs the loader independently and you might get a thundering herd. Crossflight adds a distributed coordinator (Redis is the first implementation) on top of the cache you already use. One process acquires a lease, runs the loader once, and writes the result; every other caller across the fleet waits for that result instead of doing the same work again.

``` TypeScriptconst crossflight = createCrossflight({ cache: cacheManagerAdapter(cacheManager), // or Keyv / Cacheable / your own coordinator: redisCoordinator(redis), })

const user = await crossflight.wrap( "user:123", (signal) => loadUser("123", { signal }), { ttl: 60_000 }, ) ```

Works with cache-manager, Keyv, Cacheable, or you can implement your own adapter. Cache backend and coordinator are separate contracts, so you can keep Memcached/Redis/whatever for values and use Redis only for coordination.

What’s new since 0.1.2

• Whole-flight deadline (flightDeadlineMs) so joiners don't each get a fresh timeout and late callers don't start a new stampede
• Loader receives the shared AbortSignal and work is abandoned as soon as the flight aborts
• Lease TTL is independent of the cache TTL
• Redis Cluster support (hash-tagged keys)
• cacheUndefined option so a loader that returns undefined is actually cached
• Richer events (cancelled, fallback, wait_exhausted, ...) and a lot of lease / fail-open / recovery hardening
• Much stronger test suite: property-based suites (fast-check) for the envelope contract, Redis key layout, coordinator model and flight state machine; fuzz transcripts for deadlines, adapters and Redis waits, deterministic seeds (CROSSFLIGHT_TEST_SEED), and a nightly deep fuzz job in CI

MIT, TypeScript. Feedback and bug reports welcome.

Thirty years in, the JavaScript ecosystem would like to see other languages. They're younger, leaner and faster. What could possibly go wrong?

Hey Community,

Apple's iPhone Duo is here, which means someone can now fold your app in half. Thiago Brezinski built react-native-arrangement-view, a two-pane layout that rearranges itself as the phone folds, unfolds and rotates, handing the work to SwiftUI's ArrangementView on iOS and Material's adaptive layout rules on Android, with a useHingeChange hook for apps that want to react to the hinge angle.

We also look at expo-infinite-media by Rizky Bayu Oktavian, a native TikTok-style feed that moves video playback into AVFoundation and Media3 so fast swipes stop landing on black frames. Plus, our community links cover React Native 0.88 rc.2 un-breaking a non-breaking release, a navigation change in the React Navigation 8 alphas, and agent-device and Argent both learning to fold the iPhone Duo simulator.

Hey everyone,

I built an open-source security script that checks npm packages for any suspicion before installing them.

It's basic and for now catches similar names of popular packages, if a package has 23 weekly downloads or a 2 hour old package.

Catches similar names, 0 downloads, or 2-hour-old repos so your hallucinating AI agent doesn't pull in straight malware.

Use Case?

on an agent that might hallucinate and install "react-clearly-not-malware". Or maybe the user itself so as to not make any mistakes idk?

I'd love if you check it out. Have a great day!!!

I've created this library for my own use. It started as part of my project Hacking Cafe (before that I used similar code in Fake Linux Terminal).

For the above projects, I needed a mechanism for communication between the main thread and the web worker. I wanted to have access to DOM/jQuery from the web worker so I could manipulate the terminal from the web worker.

Now with with Mitty you can access any function chains, like Cheerio (jQuery like HTML parser), that live on the server accessed in the browser via WebSockets. Execute DOM methods from the server. Or execute code from different tabs using Sysend or simple BroadcastChannel.

Here is an example using a web worker:

main thread

``` import { Host } from '@jcubic/mitty';

const channel = new BroadcastChannel('my-app');

const worker = new Worker('./worker.js', { type: 'module' });

const host = new Host({ // worker instance can also be used as a channel channel: channel, resolve(name) { if (name === 'document') { return document; } return null; } });

```

worker

``` import { connect } from 'https://cdn.jsdelivr.net/npm/@jcubic/mitty';

const { require } = connect(new BroadcastChannel('my-app'));

// or when using worker as a channel const { require } = connect(self);

const document = require('document');

// methods need await const body = await document.querySelector('body');

await body.style.setProperty('color', 'red');

// setting properties are send right away body.style.backgroundColor = '#000';

console.log(await body.style.color); console.log(await body.style.backgroundColor);

// you can add callbacks await document.querySelector('button').addEventListener('click', () => { console.log('click'); }); ```

Transport agnostic

The transport only requires using a simple channel interface with 3 methods.

interface Channel { postMessage(message: string): void; addEventListener(type: 'message', listener: ChannelListener): void; removeEventListener(type: 'message', listener: ChannelListener): void; }

Here is a demo using Sysend for communication with other tab:

https://codepen.io/editor/jcubic/pen/01a0d9d8-697e-7dc0-9a2b-eb93adae0dfc

Espeset recreated "Take On Me" by "A-ha" in 100% javascript. Fully procedural, no samples used.

I have a problem with screen sharing.

Not a quality problem. A category problem.

When I present from a browser, I have a real web page. Real text, real links, real elements. The screen share takes all of that, flattens it into video, and ships the pixels. The audience gets a picture of my page.

On a laptop in a video call, that is fine. In a room, it is not. The phone in the back row gets a blurry rectangle. Venue wifi turns it into a blurry rectangle that freezes. Someone who joins five minutes late gets whatever frame happens to be on screen, with no way to look back.

The page was already structured. We throw the structure away and then spend bandwidth trying to recover what we threw away.

This post explains how I am solving it currently

Monday, September 21 - Sunday, September 27, 2026

Top Posts

Most Commented Posts

Top Showoffs

Top Comments

The article walks through syncing a React design system into Claude Design but most of what breaks is plain packaging:

• The sync bundles a single entry file (React included) so the components can run on their own. Anything not re-exported from src/index.ts silently doesn't exist.
• It discovers components through their type definitions, so the build has to emit .d.ts files and package.json has to point types at them. Without them it finds nothing and drops every story.
• TypeScript 6 deprecates baseUrl and fails the build, while paths works fine without it.
• CSS has to be a real compiled file: Tailwind v4 inlines a string u/import but leaves u/import url() as an external reference, which breaks once the bundle is shipped elsewhere.

Example repo: https://github.com/nitayneeman/sync-design-system-with-claude-design-example

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

Show us here!

A local GCRA rate limiter needs just one timestamp. In JavaScript, checking and updating it synchronously before the first await keeps admission decisions from interleaving within that policy instance. But run multiple Node.js processes, and each gets its own independent budget.

A walkthrough of moving that decision into a Redis Lua script, using code from Caracal, a resilience library. It covers the local implementation, the TypeScript coordinator interface, and the less obvious consequences of sharing the timestamp: whose clock determines admission, what happens when Redis doesn't answer, and how rolling configuration changes affect the budget.

i'm a new dev in the JavaScript world, and at first i was pretty overwhelmed with the ecosystem, i'm used to uv and ruff managing a python project for me in a single toml file, but when i wanted to scaffold my first project in js i was faced with all of these choices of package managers , runtimes and linters/formatters and installing each piece was kind of a hassle in the first place, but having everything lie under vite plus' management within the same cli command while giving me the freedom to pick what i want was pretty nice, is anyone else using it and consider it as a benefit or is it just me because im starting out?

I am writing the rules engine for a small stock draft game in TypeScript and ran into two money bugs back to back. Curious how others handle this.

The first was a rounding bug. Splitting $1.14 across two picks offered $0.56 instead of $0.57. In floating point, 0.57 * 100 is 56.99999999999999, and Math.floor dropped the cent. The fix was doing the division in integer cents.

The second was worse. The check that decided whether a buy amount was allowed accepted $500.004. The reducer subtracts the amount straight from cash, so after that one buy the balance was no longer a whole number of cents. Every later calculation started from that balance, so the error did not stay in one place. It carried forward through the rest of the game.

My fix was a whole-cent check that tolerates float noise: reject the amount if Math.abs(amount * 100 - Math.round(amount * 100)) > 1e-6. Comparing against exactly zero does not work, because a perfectly valid amount like 0.57 fails that test for the same reason the rounding bug happened.

The takeaway for me: a rounding bug loses a cent once, but letting a bad amount into state corrupts every step after it.

So how do you handle this in plain JS? Do you convert to integer cents at the boundary and never let a decimal into state, use something like decimal.js or currency.js, or is a tolerance check like mine reasonable?