tsdkarc 1.0.0

package/README.md

@@ -0,0 +1,244 @@
+# <a href="https://arc.tsdk.dev" align="center"><img src="./assets/logo.jpg" align="center" width="30px" height="30px" style="border-radius: 4px;margin-right:4px;" alt="TsdkArc: the Elegant, fully type-safe module composition library" /></a> TsdkArc
+
+<a href="https://arc.tsdk.dev">
+<img src="./assets/banner.jpg" width="100%" style="border-radius: 24px" alt="TsdkArc: the Elegant, fully type-safe module composition library" /></a>
+
+<div align="center">The Elegant, Fully Type-safe Module Composition Library.
+</div>
+
+---
+
+## Why `TsdkArc`
+
+Application codebases grow, the code become coupled and messy — hard to reuse, hard to share.
+`TsdkArc` lets you compose modules like building blocks, nest them, and share them type safely across projects.
+
+In **tsdkrc**, Each module declares what it needs and what it provides. Then call `start([modules])` will resolves the full dependency graph, boots modules in order, and returns a typed context.
+
+## Quick Start
+
+```bash
+npm install tsdkarc
+```
+
+```ts
+import start, { defineModule } from "tsdkarc";
+
+interface ConfigSlice {
+  config: { port: number; env: string };
+}
+
+const configModule = defineModule<ConfigSlice>()({
+  name: "config",
+  modules: [],
+  boot(ctx) {
+    ctx.set("config", {
+      env: process.env.NODE_ENV ?? "development",
+      port: Number(process.env.PORT) || 3000,
+    });
+  },
+});
+
+// Run
+(async () => {
+  const app = await start([configModule]);
+  console.log(app.ctx.config.port); // 3000
+  await app.stop();
+})();
+```
+
+---
+
+## Core Concepts
+
+| Term        | Description                                                                                     |
+| ----------- | ----------------------------------------------------------------------------------------------- |
+| **Slice**   | The shape a module adds to the shared context (`{ key: Type }`)                                 |
+| **Module**  | Declares dependencies (`modules`), registers values (`ctx.set`), and optionally tears them down |
+| **Context** | The merged union of all slices — fully typed at each module's boundary                          |
+
+## API Outline
+
+```ts
+defineModule<OwnSlice>()({
+  name: string,
+  modules: Module[],
+  boot?(ctx): void | Promise<void>,
+  beforeBoot?(ctx): void | Promise<void>,
+  afterBoot?(ctx): void | Promise<void>,
+  shutdown?(ctx): void | Promise<void>,
+  beforeShutdown?(ctx): void | Promise<void>,
+  afterShutdown?(ctx): void | Promise<void>,
+})
+
+start(modules: Module[], hooks?: {
+  beforeBoot?(ctx): void | Promise<void>,
+  afterBoot?(ctx): void | Promise<void>,
+  beforeShutdown?(ctx): void | Promise<void>,
+  afterShutdown?(ctx): void | Promise<void>,
+}): Promise<{ ctx, stop() }>
+```
+
+---
+
+## Dependency Chain
+
+Downstream modules declare upstream modules and get their context fully typed.
+
+```ts
+interface DbSlice {
+  db: Pool;
+}
+
+const dbModule = defineModule<DbSlice>()({
+  name: "db",
+  modules: [configModule], // ctx.config is typed here
+  async boot(ctx) {
+    const pool = new Pool({ connectionString: ctx.config.databaseUrl });
+    await pool.connect();
+    ctx.set("db", pool);
+  },
+  async shutdown(ctx) {
+    await ctx.db.end();
+  },
+});
+
+interface ServerSlice {
+  server: http.Server;
+}
+
+const serverModule = defineModule<ServerSlice>()({
+  name: "server",
+  modules: [configModule, dbModule], // ctx.config + ctx.db both typed
+  boot(ctx) {
+    ctx.set("server", http.createServer(myHandler));
+  },
+  afterBoot(ctx) {
+    ctx.server.listen(ctx.config.port);
+  },
+  shutdown(ctx) {
+    ctx.server.close();
+  },
+});
+
+const app = await start([serverModule]);
+await app.stop();
+```
+
+`start()` walks the dependency graph and deduplicates — each module boots exactly once regardless of how many times it appears in `modules` arrays.
+
+---
+
+## Global Hooks
+
+Use the second argument to `start()` for process-level concerns that need access to the full context.
+
+```ts
+const app = await start([serverModule], {
+  afterBoot(ctx) {
+    process.on("uncaughtException", (err) => console.error(err));
+  },
+  beforeShutdown(ctx) {
+    console.info("shutting down");
+  },
+  afterEachBoot(ctx) {
+    console.info("booting", mod.name);
+  },
+  beforeEachShutdown(ctx, mod) {
+    console.info("shutting down", mod.name);
+  },
+});
+```
+
+---
+
+## Patterns
+
+**Register anything, not just data.** Functions, class instances, and middleware are all valid context values.
+
+```ts
+interface AuthSlice {
+  authenticate: (req: Request, res: Response, next: NextFunction) => void;
+}
+
+const authModule = defineModule<AuthSlice>()({
+  name: "auth",
+  modules: [],
+  boot(ctx) {
+    ctx.set("authenticate", (req, res, next) => {
+      if (!req.headers.authorization) return res.status(401).end();
+      next();
+    });
+  },
+});
+```
+
+**Compose small modules.** Each module is independently testable and replaceable. Complex wiring is just a chain of dependencies.
+
+```ts
+// config → db → cache → queue → server
+const app = await start([serverModule]);
+```
+
+---
+
+## Lifecycle
+
+```
+beforeBoot → boot → afterBoot → [running] → beforeShutdown → shutdown → afterShutdown
+```
+
+| Hook                 | Purpose                                                                        |
+| -------------------- | ------------------------------------------------------------------------------ |
+| `beforeBoot`         | Pre-setup, Called once before the first module begins booting.                 |
+| `boot`               | Register values on `ctx` via `ctx.set()`                                       |
+| `afterBoot`          | Called once after the last module has finished booting.                        |
+| `beforeShutdown`     | Called once before the first module begins shutting down.                      |
+| `shutdown`           | Release resources                                                              |
+| `afterShutdown`      | Called once after the last module has finished shutting down.                  |
+| `beforeEachBoot`     | Called before each individual module boots, in boot order.                     |
+| `afterEachBoot`      | Called after each individual module finishes booting, in boot order.           |
+| `beforeEachShutdown` | Called before each individual module shuts down, in shutdown order.            |
+| `afterEachShutdown`  | Called after each individual module finishes shutting down, in shutdown order. |
+
+---
+
+## API
+
+### `defineModule<Slice>()(config)`
+
+| Field            | Type                       | Description                   |
+| ---------------- | -------------------------- | ----------------------------- |
+| `name`           | `string`                   | Unique module identifier      |
+| `description`    | `string`                   | Optional description          |
+| `modules`        | `Module<Slice>[]`          | Declared dependencies         |
+| `beforeBoot`     | `(ctx) => void \| Promise` | Runs before boot              |
+| `boot`           | `(ctx) => void \| Promise` | Register values on ctx        |
+| `afterBoot`      | `(ctx) => void \| Promise` | Runs after all modules booted |
+| `beforeShutdown` | `(ctx) => void \| Promise` | Runs before shutdown          |
+| `shutdown`       | `(ctx) => void \| Promise` | Release resources             |
+| `afterShutdown`  | `(ctx) => void \| Promise` | Runs after shutdown           |
+
+### `start(roots, options?)` → `{ ctx, stop }`
+
+| Field     | Description                            |
+| --------- | -------------------------------------- |
+| `roots`   | Top-level modules (deps auto-resolved) |
+| `options` | Global lifecycle hooks                 |
+| `ctx`     | Merged, fully-typed context            |
+| `stop`    | Triggers full shutdown sequence        |
+
+## Projects You May Also Be Interested In
+
+- [xior](https://github.com/suhaotian/xior) - A tiny but powerful fetch wrapper with plugins support and axios-like API
+- [tsdk](https://github.com/tsdk-monorepo/tsdk) - Type-safe API development CLI tool for TypeScript projects
+- [broad-infinite-list](https://github.com/suhaotian/broad-infinite-list) - ⚡ High performance and Bidirectional infinite scrolling list component for React and Vue3
+- [littkk](https://github.com/suhaotian/littkk) - 🧞‍♂️ Shows and hides UI elements on scroll.
+
+## Reporting Issues
+
+Found an issue? Please feel free to [create issue](https://github.com/tsdk-monorepo/tsdkarc/issues/new)
+
+## Support
+
+If you find this project helpful, consider [buying me a coffee](https://github.com/tsdk-monorepo/tsdkarc/stargazers).

package/esm/index.d.ts

@@ -0,0 +1,175 @@
+/**
+ * tsdkarc.ts
+ *
+ * Minimal module lifecycle manager.
+ *
+ * Exports: Module, defineModule, ContextWriter, Logger, LifecycleHooks, StartOptions, start.
+ *
+ * Type helpers (internal):
+ *   UnionToIntersection<U>  — U1 | U2 | U3  →  U1 & U2 & U3
+ *   SliceOf<M>              — extracts S (full context) from Module<S, Sl>
+ *   MergeSlices<Tuple>      — intersects all S from a modules tuple
+ *   FullContext<Deps, Own>  — MergeSlices<Deps> & Own
+ *
+ * Internal functions use AnyModule (Module<object, object>) at boundaries
+ * where generic params are intentionally erased — the runtime does not need them.
+ */
+/**
+ * ContextWriter<S, Sl>
+ *
+ * Reading  — direct property access on Readonly<S>:  ctx.db, ctx.config
+ * Writing  — set() restricted to OwnSlice keys only: ctx.set('auth', ...)
+ *
+ * Readonly<S> prevents ctx.db = ... at the type level.
+ * Attempting to write a dep key via set() is also a type error.
+ *
+ * Note: 'set' is a reserved key — no slice may use 'set' as a property name.
+ */
+export type ContextWriter<S extends object, Sl extends object = S> = Readonly<S> & {
+    set<K extends Exclude<keyof Sl, "set">>(key: K, value: Sl[K]): void;
+};
+/** Converts U1 | U2 | U3 into U1 & U2 & U3 via contravariance. */
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+/** Extracts full context S from a Module — so transitive deps propagate upward. */
+type SliceOf<M> = M extends Module<infer S, object> ? S : never;
+/** Merges full context S from all modules in a tuple into one intersection. */
+type MergeSlices<T extends readonly AnyModule[]> = UnionToIntersection<SliceOf<T[number]>> extends object ? UnionToIntersection<SliceOf<T[number]>> : Record<never, never>;
+/** Full context seen by a module = all deps merged context + own slice. */
+type FullContext<Deps extends readonly AnyModule[], Own extends object> = MergeSlices<Deps> & Own;
+/** Opaque alias used at internal boundaries where generic params are erased. */
+type AnyModule = Module<object, object>;
+/**
+ * Global lifecycle hooks for start().
+ *
+ * Each fires exactly once — not per-module:
+ *   beforeBoot     — before the first module boots
+ *   afterBoot      — after the last module has booted
+ *   beforeShutdown — before the first module shuts down
+ *   afterShutdown  — after the last module has shut down
+ *
+ * Per-module variants (beforeEach*, afterEach*) fire once per module,
+ * in boot/shutdown order, with the current module passed as the second argument.
+ */
+export interface LifecycleHooks<S extends object = Record<never, never>> {
+    /** Called once before the first module begins booting. */
+    beforeBoot?(ctx: ContextWriter<S>): Promise<void> | void;
+    /** Called once after the last module has finished booting. */
+    afterBoot?(ctx: ContextWriter<S>): Promise<void> | void;
+    /** Called once before the first module begins shutting down. */
+    beforeShutdown?(ctx: ContextWriter<S>): Promise<void> | void;
+    /** Called once after the last module has finished shutting down. */
+    afterShutdown?(ctx: ContextWriter<S>): Promise<void> | void;
+    /** Called before each individual module boots, in boot order. */
+    beforeEachBoot?(ctx: ContextWriter<S>, 
+    /** The module about to boot. */
+    module: Module<any>): Promise<void> | void;
+    /** Called after each individual module finishes booting, in boot order. */
+    afterEachBoot?(ctx: ContextWriter<S>, 
+    /** The module that just finished booting. */
+    module: Module<any>): Promise<void> | void;
+    /** Called before each individual module shuts down, in shutdown order. */
+    beforeEachShutdown?(ctx: ContextWriter<S>, 
+    /** The module about to shut down. */
+    module: Module<any>): Promise<void> | void;
+    /** Called after each individual module finishes shutting down, in shutdown order. */
+    afterEachShutdown?(ctx: ContextWriter<S>, 
+    /** The module that just finished shutting down. */
+    module: Module<any>): Promise<void> | void;
+}
+/**
+ * Module<S, Sl>
+ *
+ * Per-module hooks fire scoped to this module's own boot/shutdown.
+ * They receive ContextWriter<S, Sl> — same as boot/shutdown.
+ */
+export interface Module<S extends object, Sl extends object = S> {
+    name: string;
+    description?: string;
+    modules?: AnyModule[];
+    boot?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    shutdown?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    /** Called immediately before this module's own boot(). */
+    beforeBoot?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    /** Called immediately after this module's own boot(). */
+    afterBoot?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    /** Called immediately before this module's own shutdown(). */
+    beforeShutdown?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    /** Called immediately after this module's own shutdown(). */
+    afterShutdown?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+}
+/**
+ * Define a module with full context inferred from its dependency tuple.
+ *
+ * OwnSlice first — pass only what this module contributes:
+ *   defineModule<AuthSlice>()({ modules: [db, redis] as const, ... })
+ *
+ * Deps is inferred from modules — no need to pass it explicitly.
+ * Omit OwnSlice entirely if this module contributes nothing to context:
+ *   defineModule()({ modules: [db] as const, ... })
+ *
+ * Inside boot/shutdown:
+ *   ctx.db           — read dep directly (Readonly<S>)
+ *   ctx.set('auth')  — write own slice only
+ *
+ * @param def  module definition
+ */
+export declare function defineModule<OwnSlice extends object = Record<never, never>>(): <const Deps extends readonly AnyModule[] = []>(def: {
+    name: string;
+    description?: string;
+    modules?: Deps;
+    boot?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    shutdown?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    beforeBoot?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    afterBoot?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    beforeShutdown?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    afterShutdown?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+}) => Module<FullContext<Deps, OwnSlice>, OwnSlice>;
+/**
+ * Options for start(). Flat intersection — no nesting required:
+ *   start([db], { log, afterBoot: async (ctx) => ... })
+ *
+ * S is inferred from the roots tuple — no explicit type param needed.
+ */
+export type StartOptions<S extends object = Record<never, never>> = LifecycleHooks<S>;
+/**
+ * Boot all modules reachable from roots, in dependency order.
+ * Deduplicates by name across the entire tree — pass only roots.
+ * Returns stop() for graceful shutdown. stop() is idempotent.
+ *
+ * Context type is inferred from the roots tuple automatically.
+ *
+ * Global hook order:
+ *   beforeBoot → [each: beforeBoot → boot → afterBoot] → afterBoot
+ *   beforeShutdown → [each: beforeShutdown → shutdown → afterShutdown] → afterShutdown
+ *
+ * Global hooks do NOT fire during rollback — rollback is error recovery.
+ *
+ * Throws if:
+ *   - same name resolves to two different instances (collision)
+ *   - a circular dependency is detected
+ *   - any boot() fails (already-booted modules are rolled back)
+ *
+ * @param roots    root Module instances — tree walked recursively
+ * @param options  optional log + global lifecycle hooks
+ */
+export default function start<const Roots extends readonly AnyModule[]>(roots: Roots, options?: StartOptions<MergeSlices<Roots>>): Promise<{
+    stop(): Promise<void>;
+    ctx: MergeSlices<Roots>;
+}>;
+/**
+ * Walk the module tree from roots, dedupe by name, topoSort.
+ * Throws on name collision (same name, different instance).
+ */
+export declare function resolveModules(roots: AnyModule[]): AnyModule[];
+/**
+ * DFS topological sort over the registry.
+ * Throws on circular dependency.
+ */
+export declare function topoSort(registry: Map<string, AnyModule>): AnyModule[];
+/**
+ * Shut down already-booted modules in reverse order.
+ * Best-effort: logs errors, never throws.
+ * Global beforeShutdown/afterShutdown do NOT fire — rollback is error recovery.
+ */
+export declare function rollback(booted: AnyModule[], modWriter: ContextWriter<object, object>): Promise<void>;
+export {};

package/esm/index.js

@@ -0,0 +1,214 @@
+/**
+ * tsdkarc.ts
+ *
+ * Minimal module lifecycle manager.
+ *
+ * Exports: Module, defineModule, ContextWriter, Logger, LifecycleHooks, StartOptions, start.
+ *
+ * Type helpers (internal):
+ *   UnionToIntersection<U>  — U1 | U2 | U3  →  U1 & U2 & U3
+ *   SliceOf<M>              — extracts S (full context) from Module<S, Sl>
+ *   MergeSlices<Tuple>      — intersects all S from a modules tuple
+ *   FullContext<Deps, Own>  — MergeSlices<Deps> & Own
+ *
+ * Internal functions use AnyModule (Module<object, object>) at boundaries
+ * where generic params are intentionally erased — the runtime does not need them.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// ---------------------------------------------------------------------------
+// defineModule
+// ---------------------------------------------------------------------------
+/**
+ * Define a module with full context inferred from its dependency tuple.
+ *
+ * OwnSlice first — pass only what this module contributes:
+ *   defineModule<AuthSlice>()({ modules: [db, redis] as const, ... })
+ *
+ * Deps is inferred from modules — no need to pass it explicitly.
+ * Omit OwnSlice entirely if this module contributes nothing to context:
+ *   defineModule()({ modules: [db] as const, ... })
+ *
+ * Inside boot/shutdown:
+ *   ctx.db           — read dep directly (Readonly<S>)
+ *   ctx.set('auth')  — write own slice only
+ *
+ * @param def  module definition
+ */
+export function defineModule() {
+    return function (def) {
+        return def;
+    };
+}
+// ---------------------------------------------------------------------------
+// start
+// ---------------------------------------------------------------------------
+/**
+ * Boot all modules reachable from roots, in dependency order.
+ * Deduplicates by name across the entire tree — pass only roots.
+ * Returns stop() for graceful shutdown. stop() is idempotent.
+ *
+ * Context type is inferred from the roots tuple automatically.
+ *
+ * Global hook order:
+ *   beforeBoot → [each: beforeBoot → boot → afterBoot] → afterBoot
+ *   beforeShutdown → [each: beforeShutdown → shutdown → afterShutdown] → afterShutdown
+ *
+ * Global hooks do NOT fire during rollback — rollback is error recovery.
+ *
+ * Throws if:
+ *   - same name resolves to two different instances (collision)
+ *   - a circular dependency is detected
+ *   - any boot() fails (already-booted modules are rolled back)
+ *
+ * @param roots    root Module instances — tree walked recursively
+ * @param options  optional log + global lifecycle hooks
+ */
+export default function start(roots_1) {
+    return __awaiter(this, arguments, void 0, function* (roots, options = {}) {
+        var _a, _b, _c;
+        const { beforeBoot, afterBoot, beforeShutdown, afterShutdown, beforeEachBoot, afterEachBoot, beforeEachShutdown, afterEachShutdown, } = options;
+        const ctx = {};
+        const writer = makeWriter(ctx);
+        const modWriter = writer;
+        const booted = [];
+        let stopped = false;
+        const sorted = resolveModules([...roots]);
+        function doStop() {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                if (stopped)
+                    return;
+                stopped = true;
+                yield (beforeShutdown === null || beforeShutdown === void 0 ? void 0 : beforeShutdown(writer));
+                for (const mod of [...booted].reverse()) {
+                    try {
+                        yield (beforeEachShutdown === null || beforeEachShutdown === void 0 ? void 0 : beforeEachShutdown(writer, mod));
+                        yield ((_a = mod.beforeShutdown) === null || _a === void 0 ? void 0 : _a.call(mod, modWriter));
+                        yield ((_b = mod.shutdown) === null || _b === void 0 ? void 0 : _b.call(mod, modWriter));
+                        yield (afterEachShutdown === null || afterEachShutdown === void 0 ? void 0 : afterEachShutdown(writer, mod));
+                        yield ((_c = mod.afterShutdown) === null || _c === void 0 ? void 0 : _c.call(mod, modWriter));
+                    }
+                    catch (err) {
+                        throw new Error(`Module "${mod.name}" stop failed: ${errorMessage(err)}`);
+                    }
+                }
+                yield (afterShutdown === null || afterShutdown === void 0 ? void 0 : afterShutdown(writer));
+            });
+        }
+        yield (beforeBoot === null || beforeBoot === void 0 ? void 0 : beforeBoot(writer));
+        for (const mod of sorted) {
+            try {
+                yield (beforeEachBoot === null || beforeEachBoot === void 0 ? void 0 : beforeEachBoot(writer, mod));
+                yield ((_a = mod.beforeBoot) === null || _a === void 0 ? void 0 : _a.call(mod, modWriter));
+                yield ((_b = mod.boot) === null || _b === void 0 ? void 0 : _b.call(mod, modWriter));
+                yield (afterEachBoot === null || afterEachBoot === void 0 ? void 0 : afterEachBoot(writer, mod));
+                yield ((_c = mod.afterBoot) === null || _c === void 0 ? void 0 : _c.call(mod, modWriter));
+                booted.push(mod);
+            }
+            catch (err) {
+                stopped = true;
+                yield rollback(booted, modWriter);
+                throw new Error(`Module "${mod.name}" boot failed: ${errorMessage(err)}`);
+            }
+        }
+        yield (afterBoot === null || afterBoot === void 0 ? void 0 : afterBoot(writer));
+        return { stop: doStop, ctx: modWriter };
+    });
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Walk the module tree from roots, dedupe by name, topoSort.
+ * Throws on name collision (same name, different instance).
+ */
+export function resolveModules(roots) {
+    const registry = new Map();
+    function collect(mod) {
+        var _a;
+        const existing = registry.get(mod.name);
+        if (existing) {
+            if (existing !== mod) {
+                throw new Error(`Module name collision: "${mod.name}" registered with two different instances`);
+            }
+            return;
+        }
+        registry.set(mod.name, mod);
+        for (const dep of (_a = mod.modules) !== null && _a !== void 0 ? _a : [])
+            collect(dep);
+    }
+    for (const root of roots)
+        collect(root);
+    return topoSort(registry);
+}
+/**
+ * DFS topological sort over the registry.
+ * Throws on circular dependency.
+ */
+export function topoSort(registry) {
+    const visited = new Set();
+    const inStack = new Set();
+    const order = [];
+    function visit(name) {
+        var _a;
+        if (visited.has(name))
+            return;
+        if (inStack.has(name))
+            throw new Error(`Circular dependency detected at: "${name}"`);
+        const mod = registry.get(name);
+        if (!mod)
+            return;
+        inStack.add(name);
+        for (const dep of (_a = mod.modules) !== null && _a !== void 0 ? _a : [])
+            visit(dep.name);
+        inStack.delete(name);
+        visited.add(name);
+        order.push(mod);
+    }
+    for (const name of registry.keys())
+        visit(name);
+    return order;
+}
+/**
+ * Shut down already-booted modules in reverse order.
+ * Best-effort: logs errors, never throws.
+ * Global beforeShutdown/afterShutdown do NOT fire — rollback is error recovery.
+ */
+export function rollback(booted, modWriter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        for (const mod of [...booted].reverse()) {
+            try {
+                yield ((_a = mod.beforeShutdown) === null || _a === void 0 ? void 0 : _a.call(mod, modWriter));
+                yield ((_b = mod.shutdown) === null || _b === void 0 ? void 0 : _b.call(mod, modWriter));
+                yield ((_c = mod.afterShutdown) === null || _c === void 0 ? void 0 : _c.call(mod, modWriter));
+            }
+            catch (err) {
+                throw new Error(`Module "${mod.name}" rollback_shutdown_failed: ${errorMessage(err)}`);
+            }
+        }
+    });
+}
+/**
+ * ContextWriter backed by a plain Record.
+ * Direct property access for reads (via Proxy), set() for writes.
+ * Cast to ContextWriter<S> at the start() boundary.
+ */
+function makeWriter(ctx) {
+    return Object.assign(ctx, {
+        set(key, value) {
+            ctx[key] = value;
+        },
+    });
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/esm/tsconfig.esm.tsbuildinfo

@@ -0,0 +1 @@
+{"fileNames":["../node_modules/typescript/lib/lib.es5.d.ts","../node_modules/typescript/lib/lib.es2015.d.ts","../node_modules/typescript/lib/lib.dom.d.ts","../node_modules/typescript/lib/lib.es2015.core.d.ts","../node_modules/typescript/lib/lib.es2015.collection.d.ts","../node_modules/typescript/lib/lib.es2015.generator.d.ts","../node_modules/typescript/lib/lib.es2015.iterable.d.ts","../node_modules/typescript/lib/lib.es2015.promise.d.ts","../node_modules/typescript/lib/lib.es2015.proxy.d.ts","../node_modules/typescript/lib/lib.es2015.reflect.d.ts","../node_modules/typescript/lib/lib.es2015.symbol.d.ts","../node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","../node_modules/typescript/lib/lib.decorators.d.ts","../node_modules/typescript/lib/lib.decorators.legacy.d.ts","../src/index.ts","../node_modules/@types/deep-eql/index.d.ts","../node_modules/assertion-error/index.d.ts","../node_modules/@types/chai/index.d.ts","../node_modules/@types/estree/index.d.ts"],"fileIdsList":[[16,17]],"fileInfos":[{"version":"c430d44666289dae81f30fa7b2edebf186ecc91a2d4c71266ea6ae76388792e1","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"080941d9f9ff9307f7e27a83bcd888b7c8270716c39af943532438932ec1d0b9","affectsGlobalScope":true,"impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fb0f136d372979348d59b3f5020b4cdb81b5504192b1cacff5d1fbba29378aa1","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"66d99e5eea1d583803f80816a7e5b264c4bac636deb853502918e2044ef1a5f7","signature":"5d3723bdf23914654d36eda00c37a16b499e89400a515fbecdb9b3741429f4e0"},{"version":"427fe2004642504828c1476d0af4270e6ad4db6de78c0b5da3e4c5ca95052a99","impliedFormat":1},{"version":"2eeffcee5c1661ddca53353929558037b8cf305ffb86a803512982f99bcab50d","impliedFormat":99},{"version":"9afb4cb864d297e4092a79ee2871b5d3143ea14153f62ef0bb04ede25f432030","affectsGlobalScope":true,"impliedFormat":99},{"version":"151ff381ef9ff8da2da9b9663ebf657eac35c4c9a19183420c05728f31a6761d","impliedFormat":1}],"root":[15],"options":{"declaration":true,"downlevelIteration":true,"emitDecoratorMetadata":true,"esModuleInterop":true,"experimentalDecorators":true,"module":5,"noImplicitAny":true,"outDir":"./","skipLibCheck":true,"strict":true,"strictPropertyInitialization":false,"target":2},"referencedMap":[[18,1]],"version":"5.9.3"}

package/lib/index.d.ts

@@ -0,0 +1,175 @@
+/**
+ * tsdkarc.ts
+ *
+ * Minimal module lifecycle manager.
+ *
+ * Exports: Module, defineModule, ContextWriter, Logger, LifecycleHooks, StartOptions, start.
+ *
+ * Type helpers (internal):
+ *   UnionToIntersection<U>  — U1 | U2 | U3  →  U1 & U2 & U3
+ *   SliceOf<M>              — extracts S (full context) from Module<S, Sl>
+ *   MergeSlices<Tuple>      — intersects all S from a modules tuple
+ *   FullContext<Deps, Own>  — MergeSlices<Deps> & Own
+ *
+ * Internal functions use AnyModule (Module<object, object>) at boundaries
+ * where generic params are intentionally erased — the runtime does not need them.
+ */
+/**
+ * ContextWriter<S, Sl>
+ *
+ * Reading  — direct property access on Readonly<S>:  ctx.db, ctx.config
+ * Writing  — set() restricted to OwnSlice keys only: ctx.set('auth', ...)
+ *
+ * Readonly<S> prevents ctx.db = ... at the type level.
+ * Attempting to write a dep key via set() is also a type error.
+ *
+ * Note: 'set' is a reserved key — no slice may use 'set' as a property name.
+ */
+export type ContextWriter<S extends object, Sl extends object = S> = Readonly<S> & {
+    set<K extends Exclude<keyof Sl, "set">>(key: K, value: Sl[K]): void;
+};
+/** Converts U1 | U2 | U3 into U1 & U2 & U3 via contravariance. */
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+/** Extracts full context S from a Module — so transitive deps propagate upward. */
+type SliceOf<M> = M extends Module<infer S, object> ? S : never;
+/** Merges full context S from all modules in a tuple into one intersection. */
+type MergeSlices<T extends readonly AnyModule[]> = UnionToIntersection<SliceOf<T[number]>> extends object ? UnionToIntersection<SliceOf<T[number]>> : Record<never, never>;
+/** Full context seen by a module = all deps merged context + own slice. */
+type FullContext<Deps extends readonly AnyModule[], Own extends object> = MergeSlices<Deps> & Own;
+/** Opaque alias used at internal boundaries where generic params are erased. */
+type AnyModule = Module<object, object>;
+/**
+ * Global lifecycle hooks for start().
+ *
+ * Each fires exactly once — not per-module:
+ *   beforeBoot     — before the first module boots
+ *   afterBoot      — after the last module has booted
+ *   beforeShutdown — before the first module shuts down
+ *   afterShutdown  — after the last module has shut down
+ *
+ * Per-module variants (beforeEach*, afterEach*) fire once per module,
+ * in boot/shutdown order, with the current module passed as the second argument.
+ */
+export interface LifecycleHooks<S extends object = Record<never, never>> {
+    /** Called once before the first module begins booting. */
+    beforeBoot?(ctx: ContextWriter<S>): Promise<void> | void;
+    /** Called once after the last module has finished booting. */
+    afterBoot?(ctx: ContextWriter<S>): Promise<void> | void;
+    /** Called once before the first module begins shutting down. */
+    beforeShutdown?(ctx: ContextWriter<S>): Promise<void> | void;
+    /** Called once after the last module has finished shutting down. */
+    afterShutdown?(ctx: ContextWriter<S>): Promise<void> | void;
+    /** Called before each individual module boots, in boot order. */
+    beforeEachBoot?(ctx: ContextWriter<S>, 
+    /** The module about to boot. */
+    module: Module<any>): Promise<void> | void;
+    /** Called after each individual module finishes booting, in boot order. */
+    afterEachBoot?(ctx: ContextWriter<S>, 
+    /** The module that just finished booting. */
+    module: Module<any>): Promise<void> | void;
+    /** Called before each individual module shuts down, in shutdown order. */
+    beforeEachShutdown?(ctx: ContextWriter<S>, 
+    /** The module about to shut down. */
+    module: Module<any>): Promise<void> | void;
+    /** Called after each individual module finishes shutting down, in shutdown order. */
+    afterEachShutdown?(ctx: ContextWriter<S>, 
+    /** The module that just finished shutting down. */
+    module: Module<any>): Promise<void> | void;
+}
+/**
+ * Module<S, Sl>
+ *
+ * Per-module hooks fire scoped to this module's own boot/shutdown.
+ * They receive ContextWriter<S, Sl> — same as boot/shutdown.
+ */
+export interface Module<S extends object, Sl extends object = S> {
+    name: string;
+    description?: string;
+    modules?: AnyModule[];
+    boot?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    shutdown?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    /** Called immediately before this module's own boot(). */
+    beforeBoot?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    /** Called immediately after this module's own boot(). */
+    afterBoot?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    /** Called immediately before this module's own shutdown(). */
+    beforeShutdown?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+    /** Called immediately after this module's own shutdown(). */
+    afterShutdown?(ctx: ContextWriter<S, Sl>): Promise<void> | void;
+}
+/**
+ * Define a module with full context inferred from its dependency tuple.
+ *
+ * OwnSlice first — pass only what this module contributes:
+ *   defineModule<AuthSlice>()({ modules: [db, redis] as const, ... })
+ *
+ * Deps is inferred from modules — no need to pass it explicitly.
+ * Omit OwnSlice entirely if this module contributes nothing to context:
+ *   defineModule()({ modules: [db] as const, ... })
+ *
+ * Inside boot/shutdown:
+ *   ctx.db           — read dep directly (Readonly<S>)
+ *   ctx.set('auth')  — write own slice only
+ *
+ * @param def  module definition
+ */
+export declare function defineModule<OwnSlice extends object = Record<never, never>>(): <const Deps extends readonly AnyModule[] = []>(def: {
+    name: string;
+    description?: string;
+    modules?: Deps;
+    boot?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    shutdown?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    beforeBoot?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    afterBoot?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    beforeShutdown?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+    afterShutdown?(ctx: ContextWriter<FullContext<Deps, OwnSlice>, OwnSlice>): Promise<void> | void;
+}) => Module<FullContext<Deps, OwnSlice>, OwnSlice>;
+/**
+ * Options for start(). Flat intersection — no nesting required:
+ *   start([db], { log, afterBoot: async (ctx) => ... })
+ *
+ * S is inferred from the roots tuple — no explicit type param needed.
+ */
+export type StartOptions<S extends object = Record<never, never>> = LifecycleHooks<S>;
+/**
+ * Boot all modules reachable from roots, in dependency order.
+ * Deduplicates by name across the entire tree — pass only roots.
+ * Returns stop() for graceful shutdown. stop() is idempotent.
+ *
+ * Context type is inferred from the roots tuple automatically.
+ *
+ * Global hook order:
+ *   beforeBoot → [each: beforeBoot → boot → afterBoot] → afterBoot
+ *   beforeShutdown → [each: beforeShutdown → shutdown → afterShutdown] → afterShutdown
+ *
+ * Global hooks do NOT fire during rollback — rollback is error recovery.
+ *
+ * Throws if:
+ *   - same name resolves to two different instances (collision)
+ *   - a circular dependency is detected
+ *   - any boot() fails (already-booted modules are rolled back)
+ *
+ * @param roots    root Module instances — tree walked recursively
+ * @param options  optional log + global lifecycle hooks
+ */
+export default function start<const Roots extends readonly AnyModule[]>(roots: Roots, options?: StartOptions<MergeSlices<Roots>>): Promise<{
+    stop(): Promise<void>;
+    ctx: MergeSlices<Roots>;
+}>;
+/**
+ * Walk the module tree from roots, dedupe by name, topoSort.
+ * Throws on name collision (same name, different instance).
+ */
+export declare function resolveModules(roots: AnyModule[]): AnyModule[];
+/**
+ * DFS topological sort over the registry.
+ * Throws on circular dependency.
+ */
+export declare function topoSort(registry: Map<string, AnyModule>): AnyModule[];
+/**
+ * Shut down already-booted modules in reverse order.
+ * Best-effort: logs errors, never throws.
+ * Global beforeShutdown/afterShutdown do NOT fire — rollback is error recovery.
+ */
+export declare function rollback(booted: AnyModule[], modWriter: ContextWriter<object, object>): Promise<void>;
+export {};

package/lib/index.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * tsdkarc.ts
+ *
+ * Minimal module lifecycle manager.
+ *
+ * Exports: Module, defineModule, ContextWriter, Logger, LifecycleHooks, StartOptions, start.
+ *
+ * Type helpers (internal):
+ *   UnionToIntersection<U>  — U1 | U2 | U3  →  U1 & U2 & U3
+ *   SliceOf<M>              — extracts S (full context) from Module<S, Sl>
+ *   MergeSlices<Tuple>      — intersects all S from a modules tuple
+ *   FullContext<Deps, Own>  — MergeSlices<Deps> & Own
+ *
+ * Internal functions use AnyModule (Module<object, object>) at boundaries
+ * where generic params are intentionally erased — the runtime does not need them.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineModule = defineModule;
+exports.default = start;
+exports.resolveModules = resolveModules;
+exports.topoSort = topoSort;
+exports.rollback = rollback;
+// ---------------------------------------------------------------------------
+// defineModule
+// ---------------------------------------------------------------------------
+/**
+ * Define a module with full context inferred from its dependency tuple.
+ *
+ * OwnSlice first — pass only what this module contributes:
+ *   defineModule<AuthSlice>()({ modules: [db, redis] as const, ... })
+ *
+ * Deps is inferred from modules — no need to pass it explicitly.
+ * Omit OwnSlice entirely if this module contributes nothing to context:
+ *   defineModule()({ modules: [db] as const, ... })
+ *
+ * Inside boot/shutdown:
+ *   ctx.db           — read dep directly (Readonly<S>)
+ *   ctx.set('auth')  — write own slice only
+ *
+ * @param def  module definition
+ */
+function defineModule() {
+    return function (def) {
+        return def;
+    };
+}
+// ---------------------------------------------------------------------------
+// start
+// ---------------------------------------------------------------------------
+/**
+ * Boot all modules reachable from roots, in dependency order.
+ * Deduplicates by name across the entire tree — pass only roots.
+ * Returns stop() for graceful shutdown. stop() is idempotent.
+ *
+ * Context type is inferred from the roots tuple automatically.
+ *
+ * Global hook order:
+ *   beforeBoot → [each: beforeBoot → boot → afterBoot] → afterBoot
+ *   beforeShutdown → [each: beforeShutdown → shutdown → afterShutdown] → afterShutdown
+ *
+ * Global hooks do NOT fire during rollback — rollback is error recovery.
+ *
+ * Throws if:
+ *   - same name resolves to two different instances (collision)
+ *   - a circular dependency is detected
+ *   - any boot() fails (already-booted modules are rolled back)
+ *
+ * @param roots    root Module instances — tree walked recursively
+ * @param options  optional log + global lifecycle hooks
+ */
+function start(roots_1) {
+    return __awaiter(this, arguments, void 0, function* (roots, options = {}) {
+        var _a, _b, _c;
+        const { beforeBoot, afterBoot, beforeShutdown, afterShutdown, beforeEachBoot, afterEachBoot, beforeEachShutdown, afterEachShutdown, } = options;
+        const ctx = {};
+        const writer = makeWriter(ctx);
+        const modWriter = writer;
+        const booted = [];
+        let stopped = false;
+        const sorted = resolveModules([...roots]);
+        function doStop() {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                if (stopped)
+                    return;
+                stopped = true;
+                yield (beforeShutdown === null || beforeShutdown === void 0 ? void 0 : beforeShutdown(writer));
+                for (const mod of [...booted].reverse()) {
+                    try {
+                        yield (beforeEachShutdown === null || beforeEachShutdown === void 0 ? void 0 : beforeEachShutdown(writer, mod));
+                        yield ((_a = mod.beforeShutdown) === null || _a === void 0 ? void 0 : _a.call(mod, modWriter));
+                        yield ((_b = mod.shutdown) === null || _b === void 0 ? void 0 : _b.call(mod, modWriter));
+                        yield (afterEachShutdown === null || afterEachShutdown === void 0 ? void 0 : afterEachShutdown(writer, mod));
+                        yield ((_c = mod.afterShutdown) === null || _c === void 0 ? void 0 : _c.call(mod, modWriter));
+                    }
+                    catch (err) {
+                        throw new Error(`Module "${mod.name}" stop failed: ${errorMessage(err)}`);
+                    }
+                }
+                yield (afterShutdown === null || afterShutdown === void 0 ? void 0 : afterShutdown(writer));
+            });
+        }
+        yield (beforeBoot === null || beforeBoot === void 0 ? void 0 : beforeBoot(writer));
+        for (const mod of sorted) {
+            try {
+                yield (beforeEachBoot === null || beforeEachBoot === void 0 ? void 0 : beforeEachBoot(writer, mod));
+                yield ((_a = mod.beforeBoot) === null || _a === void 0 ? void 0 : _a.call(mod, modWriter));
+                yield ((_b = mod.boot) === null || _b === void 0 ? void 0 : _b.call(mod, modWriter));
+                yield (afterEachBoot === null || afterEachBoot === void 0 ? void 0 : afterEachBoot(writer, mod));
+                yield ((_c = mod.afterBoot) === null || _c === void 0 ? void 0 : _c.call(mod, modWriter));
+                booted.push(mod);
+            }
+            catch (err) {
+                stopped = true;
+                yield rollback(booted, modWriter);
+                throw new Error(`Module "${mod.name}" boot failed: ${errorMessage(err)}`);
+            }
+        }
+        yield (afterBoot === null || afterBoot === void 0 ? void 0 : afterBoot(writer));
+        return { stop: doStop, ctx: modWriter };
+    });
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Walk the module tree from roots, dedupe by name, topoSort.
+ * Throws on name collision (same name, different instance).
+ */
+function resolveModules(roots) {
+    const registry = new Map();
+    function collect(mod) {
+        var _a;
+        const existing = registry.get(mod.name);
+        if (existing) {
+            if (existing !== mod) {
+                throw new Error(`Module name collision: "${mod.name}" registered with two different instances`);
+            }
+            return;
+        }
+        registry.set(mod.name, mod);
+        for (const dep of (_a = mod.modules) !== null && _a !== void 0 ? _a : [])
+            collect(dep);
+    }
+    for (const root of roots)
+        collect(root);
+    return topoSort(registry);
+}
+/**
+ * DFS topological sort over the registry.
+ * Throws on circular dependency.
+ */
+function topoSort(registry) {
+    const visited = new Set();
+    const inStack = new Set();
+    const order = [];
+    function visit(name) {
+        var _a;
+        if (visited.has(name))
+            return;
+        if (inStack.has(name))
+            throw new Error(`Circular dependency detected at: "${name}"`);
+        const mod = registry.get(name);
+        if (!mod)
+            return;
+        inStack.add(name);
+        for (const dep of (_a = mod.modules) !== null && _a !== void 0 ? _a : [])
+            visit(dep.name);
+        inStack.delete(name);
+        visited.add(name);
+        order.push(mod);
+    }
+    for (const name of registry.keys())
+        visit(name);
+    return order;
+}
+/**
+ * Shut down already-booted modules in reverse order.
+ * Best-effort: logs errors, never throws.
+ * Global beforeShutdown/afterShutdown do NOT fire — rollback is error recovery.
+ */
+function rollback(booted, modWriter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        for (const mod of [...booted].reverse()) {
+            try {
+                yield ((_a = mod.beforeShutdown) === null || _a === void 0 ? void 0 : _a.call(mod, modWriter));
+                yield ((_b = mod.shutdown) === null || _b === void 0 ? void 0 : _b.call(mod, modWriter));
+                yield ((_c = mod.afterShutdown) === null || _c === void 0 ? void 0 : _c.call(mod, modWriter));
+            }
+            catch (err) {
+                throw new Error(`Module "${mod.name}" rollback_shutdown_failed: ${errorMessage(err)}`);
+            }
+        }
+    });
+}
+/**
+ * ContextWriter backed by a plain Record.
+ * Direct property access for reads (via Proxy), set() for writes.
+ * Cast to ContextWriter<S> at the start() boundary.
+ */
+function makeWriter(ctx) {
+    return Object.assign(ctx, {
+        set(key, value) {
+            ctx[key] = value;
+        },
+    });
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "tsdkarc",
+  "version": "1.0.0",
+  "description": "Elegant and Fully type-safe module composition library",
+  "repository": "tsdk-monorepo/tsdkarc",
+  "bugs": "https://github.com/tsdk-monorepo/tsdkarc/issues",
+  "homepage": "https://www.npmjs.com/package/tsdkarc",
+  "main": "lib/index.js",
+  "module": "esm/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib/*",
+    "esm/*",
+    "assets",
+    "README.md"
+  ],
+  "keywords": [
+    "typesafe",
+    "tsdk",
+    "dependency injection",
+    "di"
+  ],
+  "license": "MIT"
+}