@rhythmjs/rhythm 0.0.10 → 0.0.12

package/README.md

@@ -1,13 +1,13 @@
 # @rhythmjs/rhythm
 
-The core composition kernel `@rhythmjs/router` and `@rhythmjs/cli` are built on. Framework-agnostic — no router, no HTTP layer, and never will be.
+The composition kernel at the core of Rhythm, the Bun-native backend framework, the piece `@rhythmjs/router` and `@rhythmjs/cli` are built on. It gives an application its structure (onion middleware, lifecycle-managed providers, encapsulated modules, all checked at compile time) and deliberately nothing else: no router, no HTTP layer, and never will be.
 
 ## Concepts
 
-- **Onion middleware** — `use()` wraps downstream steps, running code before _and_ after `next()`.
-- **Providers** — `provide()` registers a value or async factory that resolves once and joins the context at its position in the chain: only middleware (and mounted controllers) added after it see the value. A returned key prefixed with `#` (e.g. `"#close"`) stays out of context but is still passed in full to `dispose()`.
-- **Encapsulated modules** — `register()` mounts a child `Rhythm`; its context stays sealed unless you explicitly export fields from it.
-- **Readonly context** — the context passed to middleware is deeply readonly at the type level; state only changes via `next(extra)`, or through a value branded with the `RhythmMutable` symbol (how `RhythmRouter`/`RhythmCli`'s response objects stay mutable).
+- **Onion middleware**: `use()` wraps downstream steps, running code before _and_ after `next()`.
+- **Providers**: `provide()` registers a value or async factory that resolves once and joins the context at its position in the chain: only middleware (and mounted controllers) added after it see the value. A returned key prefixed with `#` (e.g. `"#close"`) stays out of context but is still passed in full to `dispose()`.
+- **Encapsulated modules**: `register()` mounts a child `Rhythm`; its context stays sealed unless you explicitly export fields from it.
+- **Readonly context**: the context passed to middleware is deeply readonly at the type level; state only changes via `next(extra)`, or through a value branded with the `RhythmMutable` symbol (how `RhythmRouter`/`RhythmCli`'s response objects stay mutable).
 
 ## Example
 
@@ -32,7 +32,7 @@ await app.run({ userId: "u1" });
 await app.teardown();
 ```
 
-`provide()` factories run once, in declaration order, each receiving everything resolved so far via `deps`. On each `run()`, the whole chain — middleware and provider injections alike — executes in registration order, onion-style: everything only applies to what was chained after it.
+`provide()` factories run once, in declaration order, each receiving everything resolved so far via `deps`. On each `run()`, the whole chain, middleware and provider injections alike, executes in registration order, onion-style: everything only applies to what was chained after it.
 
 ### Module registration
 
@@ -55,13 +55,13 @@ const app = new Rhythm<{ userId: string }>()
 
 ## API
 
-- `new Rhythm<TInput>(options?)` — creates a pipeline; `options.name`/`options.type` label errors from `register()`.
-- `.use(fn: (ctx, next) => Promise<void> | void)` — add an onion middleware step.
-- `.provide(factory: (deps) => TValue | Promise<TValue>, dispose?)` — register a provider; resolved once, injected at its chain position, disposed in reverse order on `teardown()`.
-- `.register(other: Rhythm, exportValue?)` — mount a child `Rhythm` module; sealed by default, opt in via `exportValue`. Controllers (`RhythmRouter`, `RhythmCli`) are not modules — they mount via `.use()` instead.
-- `.run(input)` — runs `setup()` if needed, dispatches `input` through the middleware chain.
-- `.callback()` — returns the cached, reusable `(input) => Promise<TContext>` handler `run()` uses internally.
-- `.middleware()` — returns this instance as a plain middleware, for flat mounting into a parent via `.use()` instead of `.register()`.
-- `.setup()` — resolves all providers, cascading into registered modules. Idempotent; retryable on failure.
-- `.teardown()` — disposes all providers in reverse order, cascading into registered modules.
-- `compose(middleware[])` — the standalone Koa-style onion dispatcher `Rhythm` is built on.
+- `new Rhythm<TInput>(options?)`: creates a pipeline; `options.name`/`options.type` label errors from `register()`.
+- `.use(fn: (ctx, next) => Promise<void> | void)`: add an onion middleware step.
+- `.provide(factory: (deps) => TValue | Promise<TValue>, dispose?)`: register a provider; resolved once, injected at its chain position, disposed in reverse order on `teardown()`.
+- `.register(other: Rhythm, exportValue?)`: mount a child `Rhythm` module; sealed by default, opt in via `exportValue`. Controllers (`RhythmRouter`, `RhythmCli`) are not modules; they mount via `.use()` instead.
+- `.run(input)`: runs `setup()` if needed, dispatches `input` through the middleware chain.
+- `.callback()`: returns the cached, reusable `(input) => Promise<TContext>` handler `run()` uses internally.
+- `.middleware()`: returns this instance as a plain middleware, for flat mounting into a parent via `.use()` instead of `.register()`.
+- `.setup()`: resolves all providers, cascading into registered modules. Idempotent; retryable on failure.
+- `.teardown()`: disposes all providers in reverse order, cascading into registered modules.
+- `compose(middleware[])`: the standalone Koa-style onion dispatcher `Rhythm` is built on.

package/dist/compose.d.ts

@@ -1,11 +1,10 @@
-import { DeriveMiddleware, Middleware, NextFn } from "./types.js";
-//#region src/compose.d.ts
-type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+import type { DeriveMiddleware, Middleware, NextFn } from "./types";
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
 type ContextOf<M> = M extends Middleware<infer C> ? C : never;
 type ExtraOf<M> = M extends DeriveMiddleware<any, infer E> ? E : {};
 export type ComposedMiddleware<TContext extends object, TExtra extends object> = ((context: TContext, next?: NextFn<TContext>) => Promise<TContext>) & Middleware<TContext> & {
-  readonly "~derive": TExtra;
+    readonly "~derive": TExtra;
 };
 export declare function compose<const TMiddleware extends readonly Middleware<any>[]>(middleware: TMiddleware): ComposedMiddleware<UnionToIntersection<ContextOf<TMiddleware[number]>> & {}, UnionToIntersection<ExtraOf<TMiddleware[number]>> & {}>;
 export declare function compose<TContext extends object>(middleware: Middleware<TContext>[]): (context: TContext, next?: NextFn<TContext>) => Promise<TContext>;
-//#endregion
+export {};

package/dist/compose.js

@@ -1,24 +1,7 @@
-//#region src/compose.ts
-function compose(middleware) {
-	if (!Array.isArray(middleware)) throw new TypeError("Middleware stack must be an array!");
-	for (const fn of middleware) if (typeof fn !== "function") throw new TypeError("Middleware must be composed of functions!");
-	return function(context, next) {
-		let index = -1;
-		return dispatch(0);
-		function dispatch(i) {
-			if (i <= index) return Promise.reject(/* @__PURE__ */ new Error("next() called multiple times"));
-			index = i;
-			const fn = i === middleware.length ? next : middleware[i];
-			if (!fn) return Promise.resolve(context);
-			const dispatchNext = () => dispatch(i + 1);
-			try {
-				const call = fn;
-				return Promise.resolve(call(context, dispatchNext)).then(() => context);
-			} catch (err) {
-				return Promise.reject(err);
-			}
-		}
-	};
-}
-//#endregion
-export { compose };
+// @bun
+import {
+  compose2
+} from "./rhythm-d9ycs7zz.js";
+export {
+  compose2 as compose
+};

package/dist/rhythm-d9ycs7zz.js

@@ -0,0 +1,31 @@
+// @bun
+// src/compose.ts
+function compose2(middleware) {
+  if (!Array.isArray(middleware))
+    throw new TypeError("Middleware stack must be an array!");
+  for (const fn of middleware) {
+    if (typeof fn !== "function")
+      throw new TypeError("Middleware must be composed of functions!");
+  }
+  return function(context, next) {
+    let index = -1;
+    return dispatch(0);
+    function dispatch(i) {
+      if (i <= index)
+        return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      const fn = i === middleware.length ? next : middleware[i];
+      if (!fn)
+        return Promise.resolve(context);
+      const dispatchNext = () => dispatch(i + 1);
+      try {
+        const call = fn;
+        return Promise.resolve(call(context, dispatchNext)).then(() => context);
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+  };
+}
+
+export { compose2 };

package/dist/rhythm.d.ts

@@ -1,22 +1,20 @@
-import { DeriveMiddleware, Middleware, OmitHashKeys } from "./types.js";
-//#region src/rhythm.d.ts
+import type { DeriveMiddleware, Middleware, OmitHashKeys } from "./types";
 export interface RhythmOptions {
-  name?: string;
-  type?: string;
-  [key: string]: unknown;
+    name?: string;
+    type?: string;
+    [key: string]: unknown;
 }
 export declare function derive<TContext extends object, TExtra extends object>(fn: (ctx: TContext) => TExtra | Promise<TExtra>): DeriveMiddleware<TContext, OmitHashKeys<TExtra>>;
 export declare class Rhythm<TInput extends object = {}, TContext extends object = TInput, TProviders extends object = {}> {
-  #private;
-  constructor(options?: RhythmOptions);
-  use<TExtra extends object>(fn: DeriveMiddleware<TContext, TExtra>): Rhythm<TInput, TContext & TExtra, TProviders>;
-  use(fn: Middleware<TContext>): this;
-  provide<TValue extends object>(factory: (deps: TProviders) => TValue | Promise<TValue>, dispose?: (value: TValue) => void | Promise<void>): Rhythm<TInput, TContext & OmitHashKeys<TValue>, TProviders & OmitHashKeys<TValue>>;
-  register<TRegInput extends object, TRegContext extends object, TExported extends object = {}>(other: Rhythm<TRegInput, TRegContext, any> & (TContext extends TRegInput ? unknown : never), exportValue?: (result: TRegContext) => TExported): Rhythm<TInput, TContext & TExported, TProviders>;
-  setup(): Promise<void>;
-  teardown(): Promise<void>;
-  callback(): (input: TInput) => Promise<TContext>;
-  run(input: TInput): Promise<TContext>;
-  middleware(): Middleware<TContext>;
+    #private;
+    constructor(options?: RhythmOptions);
+    use<TExtra extends object>(fn: DeriveMiddleware<TContext, TExtra>): Rhythm<TInput, TContext & TExtra, TProviders>;
+    use(fn: Middleware<TContext>): this;
+    provide<TValue extends object>(factory: (deps: TProviders) => TValue | Promise<TValue>, dispose?: (value: TValue) => void | Promise<void>): Rhythm<TInput, TContext & OmitHashKeys<TValue>, TProviders & OmitHashKeys<TValue>>;
+    register<TRegInput extends object, TRegContext extends object, TExported extends object = {}>(other: Rhythm<TRegInput, TRegContext, any> & (TContext extends TRegInput ? unknown : never), exportValue?: (result: TRegContext) => TExported): Rhythm<TInput, TContext & TExported, TProviders>;
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+    callback(): (input: TInput) => Promise<TContext>;
+    run(input: TInput): Promise<TContext>;
+    middleware(): Middleware<TContext>;
 }
-//#endregion

package/dist/rhythm.js

@@ -1,105 +1,118 @@
-import { compose } from "./compose.js";
-//#region src/rhythm.ts
+// @bun
+import {
+  compose2
+} from "./rhythm-d9ycs7zz.js";
+
+// src/rhythm.ts
 function publicEntries(value) {
-	const exported = {};
-	for (const [key, val] of Object.entries(value)) if (!key.startsWith("#")) exported[key] = val;
-	return exported;
+  const exported = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (!key.startsWith("#"))
+      exported[key] = val;
+  }
+  return exported;
 }
 function derive(fn) {
-	if (typeof fn !== "function") throw new TypeError("derive factory must be a function!");
-	const middleware = async (ctx, next) => {
-		const value = await fn(ctx);
-		Object.assign(ctx, publicEntries(value));
-		await next();
-	};
-	return middleware;
+  if (typeof fn !== "function")
+    throw new TypeError("derive factory must be a function!");
+  const middleware = async (ctx, next) => {
+    const value = await fn(ctx);
+    Object.assign(ctx, publicEntries(value));
+    await next();
+  };
+  return middleware;
 }
-var Rhythm = class {
-	#middleware = [];
-	#options;
-	#providers = [];
-	#setupPromise = null;
-	constructor(options = {}) {
-		this.#options = options;
-	}
-	use(fn) {
-		if (typeof fn !== "function") throw new TypeError("middleware must be a function!");
-		this.#middleware.push(fn);
-		return this;
-	}
-	provide(factory, dispose) {
-		const entry = {
-			factory,
-			dispose
-		};
-		this.#providers.push(entry);
-		this.#middleware.push(async (ctx, next) => {
-			Object.assign(ctx, publicEntries(entry.resolved));
-			await next();
-		});
-		return this;
-	}
-	register(other, exportValue) {
-		const module = other;
-		this.#providers.push({
-			factory: async () => {
-				await module.setup();
-				return {};
-			},
-			dispose: () => module.teardown()
-		});
-		this.#middleware.push(async (ctx, next) => {
-			let result;
-			try {
-				result = await module.run(ctx);
-			} catch (cause) {
-				const { type = "module", name = "anonymous" } = module.#options;
-				throw new Error(`registered ${type} "${name}" failed`, { cause });
-			}
-			if (exportValue) Object.assign(ctx, exportValue(result));
-			await next();
-		});
-		return this;
-	}
-	setup() {
-		if (!this.#setupPromise) this.#setupPromise = this.#resolveProviders().catch((err) => {
-			this.#setupPromise = null;
-			throw err;
-		});
-		return this.#setupPromise;
-	}
-	async #resolveProviders() {
-		const resolved = {};
-		for (const entry of this.#providers) {
-			entry.resolved = await entry.factory(resolved);
-			Object.assign(resolved, publicEntries(entry.resolved));
-		}
-	}
-	async teardown() {
-		for (const entry of [...this.#providers].reverse()) {
-			if (entry.resolved === void 0) continue;
-			await entry.dispose?.(entry.resolved);
-			entry.resolved = void 0;
-		}
-		this.#setupPromise = null;
-	}
-	callback() {
-		const fn = compose([...this.#middleware]);
-		return async (input) => {
-			await this.setup();
-			return fn({ ...input });
-		};
-	}
-	run(input) {
-		return this.callback()(input);
-	}
-	middleware() {
-		const fn = compose([...this.#middleware]);
-		return async (ctx, next) => {
-			await this.setup();
-			await fn(ctx, next);
-		};
-	}
+
+class Rhythm {
+  #middleware = [];
+  #options;
+  #providers = [];
+  #setupPromise = null;
+  constructor(options = {}) {
+    this.#options = options;
+  }
+  use(fn) {
+    if (typeof fn !== "function")
+      throw new TypeError("middleware must be a function!");
+    this.#middleware.push(fn);
+    return this;
+  }
+  provide(factory, dispose) {
+    const entry = { factory, dispose };
+    this.#providers.push(entry);
+    this.#middleware.push(async (ctx, next) => {
+      Object.assign(ctx, publicEntries(entry.resolved));
+      await next();
+    });
+    return this;
+  }
+  register(other, exportValue) {
+    const module = other;
+    this.#providers.push({
+      factory: async () => {
+        await module.setup();
+        return {};
+      },
+      dispose: () => module.teardown()
+    });
+    this.#middleware.push(async (ctx, next) => {
+      let result;
+      try {
+        result = await module.run(ctx);
+      } catch (cause) {
+        const { type = "module", name = "anonymous" } = module.#options;
+        throw new Error(`registered ${type} "${name}" failed`, { cause });
+      }
+      if (exportValue)
+        Object.assign(ctx, exportValue(result));
+      await next();
+    });
+    return this;
+  }
+  setup() {
+    if (!this.#setupPromise) {
+      this.#setupPromise = this.#resolveProviders().catch((err) => {
+        this.#setupPromise = null;
+        throw err;
+      });
+    }
+    return this.#setupPromise;
+  }
+  async#resolveProviders() {
+    const resolved = {};
+    for (const entry of this.#providers) {
+      entry.resolved = await entry.factory(resolved);
+      Object.assign(resolved, publicEntries(entry.resolved));
+    }
+  }
+  async teardown() {
+    for (const entry of [...this.#providers].reverse()) {
+      if (entry.resolved === undefined)
+        continue;
+      await entry.dispose?.(entry.resolved);
+      entry.resolved = undefined;
+    }
+    this.#setupPromise = null;
+  }
+  callback() {
+    const fn = compose2([...this.#middleware]);
+    return async (input) => {
+      await this.setup();
+      return fn({ ...input });
+    };
+  }
+  run(input) {
+    return this.callback()(input);
+  }
+  middleware() {
+    const fn = compose2([...this.#middleware]);
+    return async (ctx, next) => {
+      await this.setup();
+      await fn(ctx, next);
+    };
+  }
+}
+export {
+  Rhythm,
+  derive
 };
-//#endregion
-export { Rhythm, derive };

package/dist/types.d.ts

@@ -1,8 +1,8 @@
-//#region src/types.d.ts
-export type OmitHashKeys<T> = { [K in keyof T as K extends `#${string}` ? never : K]: T[K]; };
+export type OmitHashKeys<T> = {
+    [K in keyof T as K extends `#${string}` ? never : K]: T[K];
+};
 export type NextFn<TContext extends object> = () => Promise<TContext>;
 export type Middleware<TContext extends object> = (ctx: TContext, next: NextFn<TContext>) => Promise<void> | void;
 export type DeriveMiddleware<TContext extends object, TExtra extends object> = Middleware<TContext> & {
-  readonly "~derive": TExtra;
+    readonly "~derive": TExtra;
 };
-//#endregion

package/dist/types.js

@@ -1 +1 @@
-export {};
+// @bun

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/rhythm",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "A minimal, type-safe onion-middleware and provider composition kernel.",
   "homepage": "https://rhythm.js.org/rhythm",
   "license": "ISC",
@@ -33,11 +33,16 @@
     "access": "public"
   },
   "devDependencies": {
+    "@types/bun": "^1.4.2",
     "@types/node": "^26.6.3",
-    "typescript": "^7.0.2",
-    "vite-plus": "^1.0.0"
+    "typescript": "^7.0.2"
   },
   "engines": {
-    "node": ">=20.19.0"
+    "bun": ">=1.2.0"
+  },
+  "scripts": {
+    "build": "bun build src/rhythm.ts src/compose.ts src/types.ts --outdir dist --root src --format esm --target bun --packages external --splitting && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
   }
 }