@quecto/*

The @quecto namespace is a collection of minimalist, zero-dependency utilities designed for Node.js and modern ECMAScript runtimes. Named after the SI prefix for $10^{-30}$ (representing the subatomic scale), this ecosystem focuses on highly constrained, single-purpose tools that leverage native platform APIs to keep dependency trees flat.

Rather than adding heavy abstraction layers to your stack, these utilities are designed to be easily read, understood, and integrated with minimal overhead.

The Philosophy

We build tools that don't exist but should, and we tear down things that do exist to make them better.

The @quecto namespace is an uncompromising exercise in minimalist systems design. We write software characterized by engineering at a low level, adhering to three unyielding pillars:

1. Reliable

Reliability is high-quality performance over a long, continuous horizon of time. It is not a feature you bolt on at the end, nor is it achieved by adding monitoring wrappers. Reliability is the natural, inevitable outcome achieved when you combine the Simple with the Durable.

2. Simple

Simplicity is a design philosophy characterized by engineering at a low level. By leveraging the absolute lowest, most deterministic method available, we systematically eliminate unnecessary failure modes.

Simple is distinct from easy.

• Easy is reaching for an external npm package to solve a primitive task, adding 500 downstream dependencies to your supply chain.
• Simple is mastering native runtime mechanics to solve that same task deterministically in under 100 lines of code.

3. Durable

Durable means constructing properly out of high-quality components using skilled labor. Our components are the core, native primitives of modern ECMAScript and Node.js. Our skilled labor is rigorous Test-Driven Development (TDD), extreme programming constraints, immutable contracts, and strict, self-imposed line-count boundaries.

The Constraints

Every package under the @quecto scope operates under absolute constraints:

• The 100-Line Kata: A core engine must be robust enough to solve a complex problem, yet compact enough to hold entirely in a developer's working memory. One hundred lines is the cognitive boundary of mastery. If a mechanism cannot be elegantly expressed within this limit, the architecture is wrong. We refine and compress until only vital structural mechanics remain, ensuring that when you read the code, you don't just use it, you absorb and remember how it works.

• Zero-Dependency Directive: A package must have exactly 0 upstream operational dependencies. Supply-chain security is treated as an absolute boundary. If you import a @quecto utility, you know exactly how many lines of code entered your codebase.

• Total Isolation: Utilities must be completely isolated and closed-loop. No module-level global variables, no ambient configurations, and no process-wide event hooks that leak across multiple instances in the same process memory.

• Platform Harmony: Work with the platform, never over it. The cleanest code is the code you didn't have to write because the engine handles it natively.

We try to build jewels, not boulders.

The Kata

Every @quecto package serves two purposes.

First, it is a production-ready, zero-dependency utility that you can import and trust. Second, it is a Kata (a strictly constrained learning exercise designed to teach you the deepest mechanics of the JavaScript runtime). We believe that installing a package should not rob you of the opportunity to understand how it works. Therefore, alongside readme.md, every package in this ecosystem includes a kata.md.

A Kata defines the rules, the traps, and the architectural phases required to build the utility from scratch. We challenge you to write it yourself before you look at our source code.

Proposals

The @quecto ecosystem is deliberately highly constrained. We do not accept packages just because they are useful; they must be foundational.

If you have an idea for a primitive that fits our philosophy, we welcome proposals. A valid proposal must define the utility, prove it can be built in under 100 lines without dependencies, and outline the kata.md that will teach its underlying mechanics.

To propose a new package, please open an issue using the Proposal Template.

Roadmap

• @quecto/test — A concurrent test runner that can be used as a drop-in replacement for node:test. It leverages AsyncLocalStorage to cleanly isolate test suites, and logs.
• @quecto/pool — A Go-style concurrency throttle for iterables and streams. It uses direct microtask hand-offs via Promise.withResolvers() to bypass array-shift allocations, executing massive queues with virtually zero memory overhead.

License

WTFNMFPL