esbuild

Used to bundle a server-only TypeScript module so validation logic could be exercised standalone. Needed a few attempts around external SDK handling and module resolution before the bundle ran.

What worked

Very fast bundling once the external and path setup was right.

What got in the way

Initial bundle attempts failed on external handling and resolution, requiring retries with different flags and a local module link.

Bundled new and touched server routes with external database packages excluded to quickly confirm they resolved and built.

What worked

Very fast targeted check that complemented the slower full typecheck.

Relied on the infrastructure framework bundler for the ingest function, adding the bundler dependency so synthesis could package the handler.

What worked

Bundling completed transparently during synthesis once the dependency was present and the output directory issue was avoided.

Bundled all new functions and the scratch verification probe for the target runtime. Early probe bundling attempts failed on format and path handling, then succeeded consistently once output format and entry paths were corrected.

What worked

Bundling was very fast and confirmed each function compiled for deployment.

What got in the way

Initial probe bundle failures required adjusting output format before the runtime could execute it.

Bundled the server helper for isolated probing without adding a test framework. The bundle step was fast and produced a runnable artifact on the first try.

What worked

Fast bundling with no configuration needed for the verification probe.

Used only as a lightweight syntax bundling check for the backfill script after tests passed. It completed without reported issues.

Bundled the new server storage module so an offline probe could exercise validation and presigned URL generation without starting the full app. The second bundle format worked.

What worked

Fast bundling with clear errors made the format fix quick.

What got in the way

The first bundle format did not match the probe script imports and had to be regenerated in a compatible format.

Used the bundler to package a throwaway verification probe for the rate limit logic into a runnable script, with a couple of initial build attempts failing before the final probe built and ran successfully.

What worked

Bundling with the native database module externalized produced a runnable probe quickly once the probe source was corrected.

Used indirectly as the bundler for serverless functions during synthesis. All functions bundled successfully once the surrounding synthesis output issue was avoided.

Bundled isolated function code through the infrastructure tooling. All four bundles compiled successfully once types were fixed.

What worked

Fast bundling with clear output made it easy to confirm every function compiled.

Bundled the new components for a Node render check after browser testing was ruled out. Needed alias and external adjustments but then confirmed the UI rendered.

What worked

Very fast bundling for verification without a browser.

What got in the way

Initial module resolution needed manual workarounds.

Bundled temporary verification scripts for Node execution, working around path alias and external native module issues to test the new server logic outside the app.

What worked

Fast bundling allowed exercising server modules with project path aliases while leaving native modules external.

What got in the way

Initial bundles failed to resolve the project alias and local modules until module resolution and working directory were adjusted.

Bundled a server-only research module into a runnable file so its formatting, filtering, error handling, and rate-limit logic could be probed without starting the full app. The bundle succeeded on the first attempt and the probe ran cleanly.

What worked

Fast bundling with quiet logging made isolated verification simple.

Used to bundle the new server helper for the scratch behavior harness. Completed fast with clear error output and no config needed.

What worked

Zero-config bundling for a server module; fast and predictable.

Used to bundle a temporary functional test for database and OAuth logic. Several bundling attempts failed on path and external-module handling before adjusting entry paths and output format produced a runnable bundle that passed all checks.

What worked

Once configured, bundling was fast and the resulting test exercised real application logic successfully.

What got in the way

Repeated bundle invocations failed without a clear cause, requiring multiple path and flag adjustments around module resolution and native externals.

Used to bundle the new server gateway module so a scratch script could exercise it with mocked responses. Bundling and execution both worked on the first attempt.

What worked

Fast bundling with no configuration made isolated verification of parsing and error branches practical.

Used to transpile and bundle the helper tool and model modules plus a scripted stub-model harness for deterministic multi-step checks.

What worked

Bundling was fast and eventually produced a working harness that validated scoping, sorting, math, search, and provider selection.

What got in the way

Module format and resolution needed iteration across bundle settings and symlinked dependencies before the harness ran.

Used to bundle a temporary TypeScript behavior probe so it could run under Node with external packages excluded. Bundling succeeded quickly and unblocked end-to-end verification of approval gating and recovery.

What worked

Fast bundling with a single command resolved module and type-stripping issues.

Installed quickly and bundled the JSX entry point for execution under the DOM fallback. The first bundle needed an automatic JSX setting change, after which bundling was fast and repeatable.

What worked

Very fast installs and bundles made it practical to iterate on the verification harness without touching the project build setup.

What got in the way

Default JSX handling did not match the project setup, requiring one rebuild flag before the bundle ran correctly.

Used the JavaScript build API to bundle a server module for an isolated token-expiry check. Early attempts failed on native module handling before an external-plus-shim approach produced a working bundle.

What worked

Bundling was fast once the native dependency was marked external.

What got in the way

Resolving the native database binding during bundling took multiple attempts.

The worker build imported esbuild and bundled the worker. Resolution first hit a nested 0.17.6, which still produced a runnable bundle. I then installed 0.25.12 directly so a clean install would not depend on that old hoisted copy.

What worked

The JavaScript API for a single-file bundle was small. Both the nested 0.17.6 import and the later 0.25.12 pin produced a worker bundle that Node could load and run.

What got in the way

A bare import resolved to 0.17.6 from an unrelated nested dependency. That version was easy to miss and a poor pin for a clean container install. A direct dev dependency was required to select a current release.

Used to bundle the new server-side throttling module so behavior probes could run directly against actual logic. Single-command transpilation worked without configuration and produced runnable output immediately.

What worked

Fast, zero-config TypeScript bundling for Node. No adjustments needed to resolve the module or run the resulting checks.

I imported esbuild and bundled the mailer modules into a temporary ESM build so they could run under plain Node. Both builds finished, and the emitted files executed. Later test failures happened in the running code after the bundle step.

What worked

The programmatic build API needed only entry points, bundle, ESM format, and the Node platform. Output was runnable immediately.