Reddit Scraper

"We will support the Deno runtime for another year with monthly releases containing bug fixes and security updates. **After that year we will end our development of the Deno runtime**. Deno will remain open source, and we welcome others who want to continue its development."

Hello, Here's a small package to do principal factor analysis in Javascript. The source is in pure AssemblyScript (compiles to both WASM and JS), and matches numerically to the Python package factor-analyzer. This might be useful to some. [https://github.com/bitanath/factor](https://github.com/bitanath/factor)

I’ve assembled an experimental TypeScript fork with a [branch ](https://github.com/metawrap-dev/TypeScript/tree/conditional-async-await)to explore conditional completion in buffered-writing pipelines. Most small writes complete immediately in memory. Occasionally, a write triggers an asynchronous flush. An API returning `void | Promise<void>` handles that efficiently, but callers repeatedly need: const pending1 = buffer.write(value1); if (pending1) await pending1; const pending2 = buffer.write(value2); if (pending2) await pending2; const pending3 = buffer.write(value3); if (pending3) await pending3; Preserving synchronous completion through several layers requires further branching or explicit continuations. I’m exploring whether we can express that sequence clearly without distributing completion bookkeeping throughout the application. The experimental syntax is: async? function writeRecord(buffer, record) { await? buffer.write(record.header); await? buffer.write(record.payload); await? buffer.write(record.trailer); } `await?` continues synchronously for plain values and suspends for thenables. `async?` returns a plain result when it completes synchronously, or a Promise when suspension is required. Errors before suspension throw synchronously; errors after suspension reject the returned Promise. Nested thenables are assimilated. I understand that introducing runtime syntax is outside TypeScript’s current design goals. This is an independent experiment and request for feedback, rather than a request to adopt nonstandard syntax upstream. The fork includes inferred union return types, declaration emit, generated JavaScript examples, runtime tests across five targets, and a discussion of historical objections. Supported short sequences and loops generate direct continuations, creating callbacks only when suspension is needed; complex bodies retain a generator fallback. Latest layered buffered-write measurements: |Implementation|Memory|Microtask flushes|File writes| |:-|:-|:-|:-| |Ordinary async/await|27.52 ms|26.19 ms|33.60 ms| |Conditional async/await|6.04 ms|5.39 ms|11.25 ms| |Manual continuations|5.94 ms|4.01 ms|10.38 ms| These are pooled medians from 27 samples per case, writing 100,000 records / 300,000 small writes on Node v24.19.0. They are synthetic measurements from a shared environment; file writes omit `fsync`. The RFC includes raw results, reproduction instructions, and limitations. I’d particularly welcome feedback on the mixed completion contract, observable timing and error behavior, generated code, and cleaner alternatives that preserve the synchronous path. [Implementation and RFC](https://github.com/metawrap-dev/TypeScript/blob/conditional-async-await/CONDITIONAL_ASYNC.md) Disclosure: The implementation, benchmarks, and documentation were developed with AI assistance.

Recently several ports of the TS compiler to Rust have been announced, including: https://github.com/pingdotgg/ts-rust https://github.com/maschwenk/tsrs https://x.com/bunjavascript/status/2107560647525548116 Over on [HN](https://news.ycombinator.com/item?id=50000877) a TypeScript dev called this "impressive work" and "crazy" which sounds about right.

Just want to share where my team is and see if anyone else is in the same spot. I went back through our last 60 merged PRs and every single one was written by an agent. Features, tests, migrations, even the type definitions. I barely write TypeScript anymore, I describe it. And the output is good, so nothing to complain. It follows our lint rules, the types are stricter than what we used to write by hand, and coderabbit catches most of the dumb stuff before a human looks The only real downside so far is when it doesn't have enough context it invents a new type instead of using the one we already have, and you end up with 3 slightly different User types Mind you this is a big monorepo, not a toy project. I didn't expect it to go this fast. But I do wonder about the day when the human in the loop is just there to click merge :/

I’ve been working on something that may be useful for people building music software on the web: **Verovio-TS - a 100% TypeScript port of Verovio.** The goal is simple: bring the Verovio engraving engine into the TypeScript ecosystem **without requiring WebAssembly**. Verovio is already an excellent engraving engine for MEI, MusicXML and symbolic music. But for some projects, having the engine itself available as native TypeScript opens up a very different set of possibilities. # Why TypeScript? I wanted to make it easier to build things where the notation engine is not just a renderer, but part of the application logic itself. For example: * Browser-based notation editors * Music education applications * MIDI ↔ MusicXML workflows * AI-assisted composition tools * AI music analysis and annotation * Interactive score editors * Music generation / transformation pipelines * Server-side music processing with Node.js * Custom notation experiments * Libraries built on top of a programmable notation model With a native TypeScript implementation, projects can potentially inspect, manipulate, extend and integrate the notation engine directly with the rest of a JavaScript/TypeScript application. # What I’m trying to achieve This is not intended to replace the original Verovio. The original C++ implementation remains the reference implementation and is an incredible piece of software. My goal is instead to provide **another option** for developers who are already working in the TypeScript ecosystem. The project is a direct port of Verovio's underlying logic and data structures into TypeScript, with the intention of preserving its behavior as closely as possible rather than creating a simplified reimplementation. That means the project is fairly deep - this is much more than wrapping an existing renderer with a TypeScript API. # Why I think this matters for AI + music I’m particularly interested in what becomes possible when symbolic music representation, notation, MIDI and AI can all live in the same environment. We're seeing more and more music AI systems that can generate or analyze symbolic music, but there is still a gap between: **AI output ➔ structured music representation ➔ editable score ➔ visual notation ➔ playback** A TypeScript-native notation engine could be one of the building blocks for connecting those pieces together. For example, an AI system could potentially generate a musical structure, modify it programmatically, inspect the resulting notation, render it, export it, and feed the result into another part of the application - all inside a unified JS/TS ecosystem. That's the direction I'm hoping this project can help explore. # Project GitHub: [https://github.com/manh9011/VerovioTS](https://github.com/manh9011/VerovioTS) NPM: [https://www.npmjs.com/package/verovio-ts](https://www.npmjs.com/package/verovio-ts) I’d really like this project to become useful beyond my own projects, especially for people experimenting with: **music + AI + symbolic music + notation + web technologies.** There are probably many things that can be built on top of this that I haven't even thought of yet. So I'm putting it out there in the hope that it gives developers **one more building block and one more choice** when creating the next generation of music software. Feedback, bug reports, comparisons with the original Verovio, and especially interesting projects built on top of it are very welcome.

Our E2E setup started on Detox, drifted into a partial Maestro move about a year in and it's been a hybrid of the two ever since depending on which screen is being tested. Detox still handles the native heavy stuff fine, Maestro's nicer for anything purely RN but neither covers everything cleanly once native modules get involved. I'm really curious what other teams have landed on for 2026, especially anyone dealing with a similarly mixed RN and native codebase.

Hi everyone, I’ve been experimenting with TypeScript to see whether it’s possible to build reusable, TypeScript only components, with HTML elements that stand out visually in the code, making the “markup” as easy to scan as HTML or JSX. The main goal is to do this entirely in TypeScript, without introducing a new syntax that requires custom parsers or editor/IDE plugins. The result is **elemen-ts**. Check out how it's done: Info and examples: [https://huberst.github.io/elemen-ts/](https://huberst.github.io/elemen-ts/) GitHub: [https://github.com/Huberst/elemen-ts](https://github.com/Huberst/elemen-ts) DOM updates are triggered exclusively by reactive adapters, which wrap your signals, RxJS observables or other reactive sources through custom adapters. You can pass these adapters to properties and attributes, use them as text children, or pass them to control structures such as `_IF` and `_EACH` to render dynamic content. If this sounds interesting, I’d love for you to give it a try! I’m curious to hear what feels intuitive, what’s confusing, and what could be improved. Questions and suggestions are very welcome. Example with \_IF, \_EACH, using reactive adapters to update the DOM. [Check out how the HTML Elements are visually distinct by semantic highlighting, because they are classes.](https://preview.redd.it/d2cb7fdjvqth1.png?width=1534&format=png&auto=webp&s=614236744ec4822cf8a5f8b0f2e075e8d5e9f2e6)

I want to make a generic `validateRequest()` function for my web server that will take in any incoming request and check some things to make sure everything is good. The problem is that each request could have a potentially different body. The way I have it set up right now is that it works to validate 1 type of request, but that's because I passed in the exact model of the request in the function's parms. `validateRequest(req: Request<object, object, RequestModel1>, someOtherParm: number): [number, string] {}` Each of the different possible bodys of a valid request will share one field - I need to be able to validate the value in this field, regardless of the shape of the body of the incoming request. I also am very security-conscious, so I want to make sure whatever solution I end up with here won't put me at risk of accepting an incoming request that is bogus or malicious. How would I modify my function to handle this?