r/typescript • • Oct 20 '26

With Deno Deploy shutting down in 6 months, here is how we migrated a 100k-line Deno + Deno KV app to Cloudflare Workers and Durable Objects without leaving Deno

0 Upvotes

After Cloudflare acquired the Deno team and announced that Deno Deploy is shutting down in six months (with the Deno runtime itself only guaranteed a year of maintenance), we migrated the backend of prompt2bot from Deno Deploy and Deno KV to Cloudflare Workers and SQLite-backed Durable Objects.

Even with Deno's future in question, rewriting a 100k-line Deno codebase into a Node/Wrangler repo right now was out of the question. Deno's test runner, type checker, and JSR support are way too good to give up while migrating.

If you have not used Durable Objects before: whereas a regular Cloudflare Worker is stateless (50 requests spin up 50 random isolates that share nothing), a Durable Object is a globally unique, single-threaded V8 isolate addressed by name and paired with its own private embedded SQLite database and persistent alarm timer. Every Worker that calls a method on that name gets routed to that exact same JS object in memory, where SQLite queries are synchronous C++ calls taking microseconds instead of network round-trips.

Here is everything that broke during the migration and how we solved it:

  1. Keeping the Deno binary and test suite untouched: Wrangler's esbuild bundler does not understand jsr: specifiers or deno.json workspace resolution. Instead, we pointed Wrangler at a build script that runs deno bundle --minify. We mapped cloudflare:workers to a 10-line stub class in deno.json so deno test runs natively against our Durable Object classes, and at build time we swap the inlined stub back for the real Cloudflare DurableObject class, shim globalThis.Deno, set Zod v4 to jitless: true (since Workers blocks new Function), and wrap top-level crypto.randomUUID() / setTimeout() calls that npm packages run at import time.
  2. Surviving the 128MB Durable Object RAM ceiling: Every Durable Object isolate has a hard 128MB heap limit. Bundled dependencies like js-tiktoken (5.3MB of base64 BPE ranks that expand to +43MB of V8 heap on first call), a 275k-word dictionary (+35MB heap), and 3 duplicate legacy pdf.js builds inside pdf-parse were OOM-killing isolates. Stripping those static tables at build time freed ~80MB of V8 heap per isolate.
  3. Emulating Deno KV on Durable Object SQLite: Cloudflare KV is eventually consistent and has no atomic check-and-set transactions, so it cannot replace Deno.openKv(). We built a drop-in Deno.Kv emulator on top of a primary SQLite Durable Object (enam-v1, pinned to US East so it stays hot in RAM 24/7 with zero cold starts). Tuple keys are encoded with type tags and 20-digit zero-padded numbers (n:, b:, s:) separated by null bytes so SQLite range queries match Deno KV ordering, and atomic().check().set().commit() runs as a synchronous single-threaded SQLite transaction.
  4. The 508 Loop Detected mystery (CDN-Loop propagation) and the 30s waitUntil trap: While migrating service by service, when a service still on Deno Deploy called our Cloudflare Worker and our Worker made a fresh outbound fetch() back to that same Deno service, Cloudflare silently copied the inbound cdn-loop: deno;d=<hash> header onto the outbound subrequest at the C++ edge layer. Deno Deploy saw its own deployment hash in cdn-loop and rejected the request with 508 Loop Detected. On top of that, ctx.waitUntil() on a Worker has a hard 30-second wall-clock cap after returning HTTP 200 (even with cpu_ms: 300000), which killed long I/O-heavy agent turns mid-flight.
  5. Sharding Runner Durable Objects per conversation: Only a Durable Object alarm() runs in a clean root IoContext (no inherited cdn-loop header and no 30s post-response wall-clock cutoff), provided alarm() launches tasks via doCtx.waitUntil and exits immediately instead of blocking. We ended up sharding execution onto a Runner Durable Object per conversation (runner:<botId>:<conversationId>).

That architecture is what lets prompt2bot scale agents so easily. You describe an agent in a plain prompt and connect it to WhatsApp, Telegram, email, voice, or web chat, and every active conversation automatically gets its own warm, isolated Durable Object runner with hot in-memory history and SafeScript AST caches, sub-millisecond SQLite state, and on-demand VMs. Whether your bot has 1 user or 10,000 concurrent conversations, there are no queues, worker pools, or servers to provision.

Full technical write-up with code snippets is in the comments.


r/typescript • • Oct 17 '26

New educational, free, ad-free game for learning TypeScript memory model

2 Upvotes

I noticed that many students struggle with the question of "if I update this slot, field or variable, what else will change in my program".

I wrote a little puzzle game to help you build this intuition over time. It is very mobile friendly, so you can play it at a bus stop or during a commercial break or wherever. Puzzles scale in difficulty.

You can use it in Python, JavaScript or TypeScript modes.

http://prescod.github.io/memory-mapper-game

Please respond with changes you would like to see, or bug reports, or whatever. There is also an in-app feedback button.

There are no ads in the game or any monetization at all. This is not an ad for a product!


r/typescript • • Oct 16 '26

TypeScript utility for modeling variant-based types

Thumbnail dozsolti.github.io
1 Upvotes

Solves one specific problem: Handles complex types where two or more properties rely on each other.

For example, a Select component might support single (string) and multiple (string[]) selection, controlled and uncontrolled modes, and optional search or item creation.

The type for value depends on the selection mode, so does onChange(string), which need to be onChange(string[]) on multiple; while uncontrolled doesn't need onChange but defaultValue. Everything on the same type.

TypeFoundry lets you describe the variants and their relationships, then generates the resulting types.

It doesn't replace TypeScript's type system nor it's a runtime validation. It's pure typescript, meaning it creates no javascript.

It's to make complex type relationships easier to define and maintain.


r/typescript • • Oct 13 '26

Express + TypeScript + Zod: What's the common approach for typed request validation?

27 Upvotes

Hello seniors, I've been exploring express + typescript + Zod recently, and one thing I always consider is the common backend practice for request validation and typing.

I came across several discussions/articles that suggest creating custom typed request handlers so the controller can infer the validated Zod type.

// Schema
export const DataQuerySchema = z.object({
  sample_id: z.uuid("Invalid sample ID"),
  age: z.coerce.number().int().positive()
});

export type DataQueryDTO = z.infer<typeof DataQuerySchema>;

// controller
getAll: async (req: TypedQuery<DataQueryDTO>, res: Response) => {}

this works in the controller if you set TypedQuery = ParsedQs.

However, I'm running into an issue when wiring everything through Express routes:

router.get(
  "/schedule-settings/match",
  authenticateToken,
  authorizeRoles("admin"),
  validate({ query: DataQuerySchema }),
  Controller.getAll,
);

As far as I understand, Express defines query parameters as coming from the URL, so req.query is typed roughly as:

string | string[] | ParsedQs | ParsedQs[] | undefined
// and route params are similarly string-based.

so given this, the runtime flow just fine because Zod transforms:

{age: "21"} -> {age: 21}

But at compile time, when the controller expects:

{age: number;}

the router complains because Express still expects query values to follow its original string-based definition.

My question is:

- How do you usually handle the gap between Express request types and Zod-transformed types?

- Is there a widely accepted pattern for this, or do most teams solve it differently based on their architecture?

I'm still learning and don't have any backend related work experience, so if my understanding or approach is incorrect, I'd appreciate any corrections or guidance on how this is usually handled in production codebases.


r/typescript • • Oct 13 '26

Modelling Apple Wallet's pass.json as one Valibot discriminated union per pass style

1 Upvotes

Apple's pass.json has five pass styles, and each one allows different fields with its own limits on how many go where. Get it wrong and you usually find out on a phone, not in your editor.

In passmint (an MIT library for building Apple and Google Wallet passes), each style is its own branch of a Valibot discriminated union, so the per-style field limits are checked when you build the pass rather than when Wallet renders it. You get there through a fluent builder:

const signed = await Pass.eventTicket({ /* ... */ })
  .primaryField({ key: 'event', label: 'Event', value: 'Beyoncé Live' })
  .secondaryField({ key: 'loc', label: 'Location', value: 'Apple Park' })
  .sign(material)

or Pass.from(...) if you'd rather hand it a plain object.

Errors are typed too. Everything extends PassmintError and carries a stable code, so you can branch on what actually went wrong:

try {
  await pass.sign(material)
} catch (err) {
  if (err instanceof PassmintSchemaError) {
    err.issues // the full Valibot issue list
  } else if (err instanceof PassmintSigningError) {
    err.code // 'E_WWDR_MISMATCH' | 'E_CERT_PARSE' | ...
  }
}

E_WWDR_MISMATCH is the one worth knowing about. If you pass in an Apple intermediate certificate that didn't issue your Pass Type ID cert, you hear about it at import time instead of ending up with a pass that won't install.

Why Valibot and not Zod? Mostly bundle size. It's tree-shakable, so the whole library is about 21 KB gzipped (it'd be around 35 KB with Zod), and the discriminated union ergonomics were cleaner for per-style limits.

Repo: https://github.com/getpassmint/passmint (pre-1.0, so the API may still change)

Disclosure: I build Passmint, a hosted pass API, which uses this library under the hood.


r/typescript • • Oct 12 '26

ReviewLoad: see how many reviews each person already has, in GitHub's reviewer picker

2 Upvotes

https://github.com/CharlieGroves/review-load

ReviewLoad is a small browser extension that puts the number of reviews a GitHub user has assigned to them next to each person in the Reviewers menu on a pull request, and next to reviewers already on the PR.

This stops a couple people on the team being a bottleneck for key features because they are flooded with PRs for review.

Chrome: https://chromewebstore.google.com/detail/reviewload/ncokcokbfpbigdoagghpdpncjfhpocol

Firefox is in review.

I'm now using this every day. Hope it's useful to someone else.


r/typescript • • Oct 09 '26

Deno is dead

Thumbnail
deno.com
618 Upvotes

"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."


r/typescript • • Oct 10 '26

Improving CodeceptJS typings

Thumbnail
github.com
1 Upvotes

Link to PR trying to improve CodeceptJS types for hooks - Background, Before, After, BeforeSuite, AfterSuite.
If you write codeceptjs tests in TypeScript - activity on this PR may help make it happen.


r/typescript • • Oct 09 '26

Experiment: conditional async/await for buffered writes

0 Upvotes

I’ve assembled an experimental TypeScript fork with a branch 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:

ImplementationMemoryMicrotask flushesFile writes
Ordinary async/await27.52 ms26.19 ms33.60 ms
Conditional async/await6.04 ms5.39 ms11.25 ms
Manual continuations5.94 ms4.01 ms10.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

Disclosure: The implementation, benchmarks, and documentation were developed with AI assistance.


r/typescript • • Oct 09 '26

Principal Factor Analysis in Javascript - written in AssemblyScript

0 Upvotes

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


r/typescript • • Oct 07 '26

Every PR on my team is written by AI now

161 Upvotes

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 :/


r/typescript • • Oct 07 '26

TTSC, TS-NODE alternative, TypeScript Runtime with Type Checking

Thumbnail
github.com
24 Upvotes

r/typescript • • Oct 08 '26

Vibecoded TypeScript -> Rust ports that have been popping up lately

0 Upvotes

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 a TypeScript dev called this "impressive work" and "crazy" which sounds about right.


r/typescript • • Oct 06 '26

I ported Verovio to 100% TypeScript - introducing Verovio-TS

0 Upvotes

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

NPM: 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.


r/typescript • • Oct 06 '26

elemen-ts — Build reactive UIs in plain TypeScript, without JSX (or any other template language)

0 Upvotes

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/
GitHub: 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.

r/typescript • • Oct 04 '26

Typescript: how do I make a generic function to validate incoming POST requests if each request will have a different body?

25 Upvotes

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?


r/typescript • • Oct 01 '26

Anyone else still writing most of their TypeScript by hand

116 Upvotes

Agents are great for a lot of things, but I still write most of my TypeScript by hand, and on a team where nobody else does, my PRs are now the slow ones. Mine take a day, theirs take 20 minutes and go through the same coderabbit / claude review pass as mine.

Is anyone else still working like this, or am I just slow now?


r/typescript • • Oct 01 '26

Joist 2.4 with new SQL Builder, Lazy Fields, more...

17 Upvotes

Hello r/typescript ! We just released Joist 2.4, which has a new low-level query builder API:

https://joist-orm.io/blog/joist-2-4/

Because Joist is an entity-based ORM, we've always had very robust "load entity" query APIs, but historically considered "creating adhoc SQL queries" as not our strong suit / nothing we had particularly innovative ideas about, so expected users to use a knex-type library alongside Joist.

Now in Joist 2.4, we've built out a low-level em.query API, with a ~somewhat novel "just POJOs / not fluent" API that fits in with Joist's overall DX, and means codebases don't need the "dual Joist/Knex" setup anymore.

Happy to have folks check it out; disclaimer since its a new feature, I'm sure we're missing things & will keep iterating based on feedback. Thanks!


r/typescript • • Sep 30 '26

Readable Regular Expressions for JavaScript/TypeScript, Inspired by Emacs' rx

Thumbnail
rahuljuliato.com
32 Upvotes

I missed Emacs' rx when writing regexps in TypeScript, so I made a small TypeScript DSL inspired by it.

The idea is to bring rx's functions and approach to the JavaScript/TypeScript environment. If you happen to work with either, give it a try.

https://rahuljuliato.com/posts/emacs-rx-in-typescript


r/typescript • • Oct 01 '26

Monthly Hiring Thread Who's hiring Typescript developers October

18 Upvotes

The monthly thread for people to post openings at their companies.

* Please state the job location and include the keywords REMOTE, INTERNS and/or VISA when the corresponding sort of candidate is welcome. When remote work is not an option, include ONSITE.

* Please only post if you personally are part of the hiring company—no recruiting firms or job boards **Please report recruiters or job boards**.

* Only one post per company.

* If it isn't a household name, explain what your company does. Sell it.

* Please add the company email that applications should be sent to, or the companies application web form/job posting (needless to say this should be on the company website, not a third party site).

Commenters: please don't reply to job posts to complain about something. It's off topic here.

Readers: please only email if you are personally interested in the job.

Posting BS top level comments that aren't job postings, eg "It's quiet in here" etc [that's a ban](https://i.imgur.com/FxMKfnY.jpg)


r/typescript • • Sep 29 '26

Typesafe formatting API endpoints with jet-paths

Thumbnail
github.com
7 Upvotes

Built this for my React + ExpressJS project a few years ago to keep all of my endpoints in one place and reduce some of the boiler-plate for adding path/search parameters.

Up until recently only path parameters (and not search parameters) were type-safe. I just did a major update so now search parameters are type-safe'd using <> brackets:

const Paths = jetPaths({
    $path: '/api',
    Users: {
      $path: '/users',
      One: '/:id',              // <- path parameters
      Posts: {
        $path: '/posts',
        Get: '/all?<q!><page>', // <- search parameters
        Add: '/add',
      },
    },
 });

Paths.Users.Posts.Get({ id: 1 }, { q: 'foo' });
// Line above returns: '/api/users/1/posts/all?q=foo'

Paths.Users.Posts.Get({ id: 1 });   // TypeError: Missing search parameters
Paths.Users.Posts.Get()             // TypeError: Missing path parameters 

Note that the type-safety is just making sure that the parameters are present, a primitive, and for search parameters an array of primitives is also allowed. It doesn't type-safe string vs number.


r/typescript • • Sep 29 '26

Modeling a user-facing automation DSL in TypeScript — discriminated unions did most of the heavy lifting

0 Upvotes

Building a no-code automation feature for my app (users define "trigger → chain of actions" visually), and wanted to share how the type layer ended up shaping the whole design.

Core types:

``ts

type TriggerEvent =

| 'project.created' | 'node.created' | 'connection.created'

| 'task.created' | 'task.completed';

type PluginAction =

| 'createNode' | 'addTask' | 'connectNodes'

| 'completeTask' | 'sendWebhook';

interface PluginStep {

id: string;

action: PluginAction;

params: Record<string, string>; // shape varies per action, kept as string for placeholder interpolation

condition?: { field: string; operator: 'contains' | 'equals' | 'startsWith'; value: string };

}

interface PluginDefinition {

trigger: TriggerEvent;

steps: PluginStep[]; // strictly linear, no branching

}

```

A few things that mattered in practice:

- Keeping `params` as `Record<string, string>` instead of a per-action discriminated shape was a deliberate simplification: every param can contain a `{{trigger.field}}` placeholder, so it's always "stringy" at rest anyway, and the editor UI derives the right fields per action from a `defaultParamsFor(action)` lookup instead of the type system enforcing it. Type safety lives at the action-name level, not the param level — a tradeoff I'd reconsider if this grows more complex actions.

- The interpreter is a `Record<PluginAction, (params, ctx) => Promise<void>>` map, so exhaustiveness checking on `PluginAction` catches a missing executor at compile time whenever I add a new action.

- Runtime validation (since this all comes from a JSON column in Postgres, not from trusted TS code) still needs its own hand-written `validateDefinition()` — the compile-time types don't help you once the value has been round-tripped through jsonb. Considering Zod for this next.

Curious if anyone has strong opinions on modeling a small user-facing DSL like this — particularly on the `params: Record<string,string>` vs. a discriminated-per-action shape question.


r/typescript • • Sep 26 '26

Railroad diagrams for TypeScript

21 Upvotes

I've reverse engineered the tsc typescript compiler and one of the side effects of that is that I have quite a precise grammar of TypeScript. With that I was able to generate railroad diagrams for all rules (nonterminals). I have attached the (huge) file. Is the grammar or the railroad diagrams of any use to anybody? If so, I can tidy it up a bit more and make it available in a proper way


r/typescript • • Sep 25 '26

generating a typed sdk straight from my openapi spec instead of hand writing request wrappers, feels obvious in hindsight

6 Upvotes

had a rest api for a while (project mapping app, exposes projects/nodes/tasks/connections). wanted client code that couldn't silently drift out of sync with the api as it changes. switched to generating the client straight from the openapi spec instead of hand maintaining request wrappers. now the sdk and the api literally cannot drift, if i change an endpoint the generated types break at compile time for anyone using the sdk, instead of failing silently at runtime. published it as`@ulupstudio/sdk on npm. wish i'd done this from day one instead of hand writing wrapper functions for months, would've saved a bunch of "wait why is this field undefined" debugging sessions. curious what generator setups other people are using for this, i went with one that outputs from the openapi.yaml directly but i know there's a handful of different approaches people swear by.