@kuckit/sdk 1.0.1 → 1.0.3

package/dist/config/define-config.d.ts

@@ -0,0 +1,3 @@
+import "../types-DxaDmkQo.js";
+import { t as defineConfig } from "../define-config-yzb59aTs.js";
+export { defineConfig };

package/dist/config/define-config.js

@@ -0,0 +1,3 @@
+import { t as defineConfig } from "../define-config-GYI_W9K6.js";
+
+export { defineConfig };

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+import { a as KuckitServerConfig, i as KuckitModuleConfig, n as KuckitConfig, o as LoadedKuckitConfig, r as KuckitDiscoveryConfig, t as KuckitClientConfig } from "../types-DxaDmkQo.js";
+import { t as defineConfig } from "../define-config-yzb59aTs.js";
+import { i as tryLoadKuckitConfig, n as hasUnifiedConfig, r as loadKuckitConfig, t as findConfigFile } from "../loader-YEqdtcKI.js";
+import "../index-CDDzqahH.js";
+export { KuckitClientConfig, KuckitConfig, KuckitDiscoveryConfig, KuckitModuleConfig, KuckitServerConfig, LoadedKuckitConfig, defineConfig, findConfigFile, hasUnifiedConfig, loadKuckitConfig, tryLoadKuckitConfig };

package/dist/config/index.js

@@ -0,0 +1,5 @@
+import { t as defineConfig } from "../define-config-GYI_W9K6.js";
+import { i as tryLoadKuckitConfig, n as hasUnifiedConfig, r as loadKuckitConfig, t as findConfigFile } from "../loader-lCPWCMYx.js";
+import "../config-BeiJJZGf.js";
+
+export { defineConfig, findConfigFile, hasUnifiedConfig, loadKuckitConfig, tryLoadKuckitConfig };

package/dist/config/loader.d.ts

@@ -0,0 +1,3 @@
+import "../types-DxaDmkQo.js";
+import { i as tryLoadKuckitConfig, n as hasUnifiedConfig, r as loadKuckitConfig, t as findConfigFile } from "../loader-YEqdtcKI.js";
+export { findConfigFile, hasUnifiedConfig, loadKuckitConfig, tryLoadKuckitConfig };

package/dist/config/loader.js

@@ -0,0 +1,3 @@
+import { i as tryLoadKuckitConfig, n as hasUnifiedConfig, r as loadKuckitConfig, t as findConfigFile } from "../loader-lCPWCMYx.js";
+
+export { findConfigFile, hasUnifiedConfig, loadKuckitConfig, tryLoadKuckitConfig };

package/dist/config/types.d.ts

@@ -0,0 +1,2 @@
+import { a as KuckitServerConfig, i as KuckitModuleConfig, n as KuckitConfig, o as LoadedKuckitConfig, r as KuckitDiscoveryConfig, t as KuckitClientConfig } from "../types-DxaDmkQo.js";
+export { KuckitClientConfig, KuckitConfig, KuckitDiscoveryConfig, KuckitModuleConfig, KuckitServerConfig, LoadedKuckitConfig };

package/dist/config/types.js

@@ -0,0 +1 @@
+export {  };

package/dist/config-BeiJJZGf.js

@@ -0,0 +1 @@
+export {  };

package/dist/container-D0DK003A.js

@@ -0,0 +1,50 @@
+import { t as registerCoreModule } from "./core.module-Ctm2stcL.js";
+import { InjectionMode, asValue, createContainer } from "awilix";
+
+//#region src/core/container.ts
+/**
+* Factory function to create a Kuckit DI container
+*
+* This is the primary entry point for applications using the SDK.
+* It creates an Awilix container with core infrastructure services pre-registered.
+*
+* @example
+* ```ts
+* const container = await createKuckitContainer({
+*   config: {
+*     databaseUrl: process.env.DATABASE_URL!,
+*     enableFileLogging: true,
+*     logDir: './logs',
+*     logLevel: 'INFO',
+*     env: 'production',
+*   },
+*   extraRegistrations: (container) => {
+*     // Register your custom services
+*     container.register({
+*       myService: asClass(MyService).singleton(),
+*     })
+*   },
+* })
+* ```
+*/
+const createKuckitContainer = async (opts) => {
+	const container = createContainer({ injectionMode: InjectionMode.PROXY });
+	container.register({ config: asValue(opts.config) });
+	registerCoreModule(container);
+	if (opts.extraRegistrations) await opts.extraRegistrations(container);
+	return container;
+};
+/**
+* Cleanup container resources gracefully
+*
+* Call this when shutting down your application to close database connections
+* and other resources.
+*/
+const disposeContainer = async (container) => {
+	const { dbPool } = container.cradle;
+	if (dbPool && typeof dbPool === "object" && "end" in dbPool && typeof dbPool.end === "function") await dbPool.end();
+};
+
+//#endregion
+export { disposeContainer as n, createKuckitContainer as t };
+//# sourceMappingURL=container-D0DK003A.js.map

package/dist/container-D0DK003A.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-D0DK003A.js","names":[],"sources":["../src/core/container.ts"],"sourcesContent":["import { createContainer, asValue, InjectionMode } from 'awilix'\nimport type { CoreContainer, CoreCradle, CoreConfig } from '../types'\nimport { registerCoreModule } from './core.module'\n\nexport interface CreateKuckitOptions {\n\t/**\n\t * Core configuration for the SDK\n\t */\n\tconfig: CoreConfig\n\n\t/**\n\t * Optional callback to register additional services after core registration\n\t */\n\textraRegistrations?: (container: CoreContainer) => void | Promise<void>\n}\n\n/**\n * Factory function to create a Kuckit DI container\n *\n * This is the primary entry point for applications using the SDK.\n * It creates an Awilix container with core infrastructure services pre-registered.\n *\n * @example\n * ```ts\n * const container = await createKuckitContainer({\n *   config: {\n *     databaseUrl: process.env.DATABASE_URL!,\n *     enableFileLogging: true,\n *     logDir: './logs',\n *     logLevel: 'INFO',\n *     env: 'production',\n *   },\n *   extraRegistrations: (container) => {\n *     // Register your custom services\n *     container.register({\n *       myService: asClass(MyService).singleton(),\n *     })\n *   },\n * })\n * ```\n */\nexport const createKuckitContainer = async (opts: CreateKuckitOptions): Promise<CoreContainer> => {\n\tconst container = createContainer<CoreCradle>({\n\t\tinjectionMode: InjectionMode.PROXY,\n\t})\n\n\t// Register config first (required by other registrations)\n\tcontainer.register({\n\t\tconfig: asValue(opts.config),\n\t})\n\n\t// Register core infrastructure\n\tregisterCoreModule(container)\n\n\t// Allow custom registrations\n\tif (opts.extraRegistrations) {\n\t\tawait opts.extraRegistrations(container)\n\t}\n\n\treturn container\n}\n\n/**\n * Cleanup container resources gracefully\n *\n * Call this when shutting down your application to close database connections\n * and other resources.\n */\nexport const disposeContainer = async (container: CoreContainer): Promise<void> => {\n\tconst { dbPool } = container.cradle\n\t// Handle unknown dbPool type - check for end method\n\tif (\n\t\tdbPool &&\n\t\ttypeof dbPool === 'object' &&\n\t\t'end' in dbPool &&\n\t\ttypeof (dbPool as { end: unknown }).end === 'function'\n\t) {\n\t\tawait (dbPool as { end: () => Promise<void> }).end()\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,wBAAwB,OAAO,SAAsD;CACjG,MAAM,YAAY,gBAA4B,EAC7C,eAAe,cAAc,OAC7B,CAAC;AAGF,WAAU,SAAS,EAClB,QAAQ,QAAQ,KAAK,OAAO,EAC5B,CAAC;AAGF,oBAAmB,UAAU;AAG7B,KAAI,KAAK,mBACR,OAAM,KAAK,mBAAmB,UAAU;AAGzC,QAAO;;;;;;;;AASR,MAAa,mBAAmB,OAAO,cAA4C;CAClF,MAAM,EAAE,WAAW,UAAU;AAE7B,KACC,UACA,OAAO,WAAW,YAClB,SAAS,UACT,OAAQ,OAA4B,QAAQ,WAE5C,OAAO,OAAwC,KAAK"}

package/dist/container-Ngzcb6LI.d.ts

@@ -0,0 +1,49 @@
+import { n as CoreContainer, t as CoreConfig } from "./types-DKCy16X1.js";
+
+//#region src/core/container.d.ts
+interface CreateKuckitOptions {
+  /**
+   * Core configuration for the SDK
+   */
+  config: CoreConfig;
+  /**
+   * Optional callback to register additional services after core registration
+   */
+  extraRegistrations?: (container: CoreContainer) => void | Promise<void>;
+}
+/**
+ * Factory function to create a Kuckit DI container
+ *
+ * This is the primary entry point for applications using the SDK.
+ * It creates an Awilix container with core infrastructure services pre-registered.
+ *
+ * @example
+ * ```ts
+ * const container = await createKuckitContainer({
+ *   config: {
+ *     databaseUrl: process.env.DATABASE_URL!,
+ *     enableFileLogging: true,
+ *     logDir: './logs',
+ *     logLevel: 'INFO',
+ *     env: 'production',
+ *   },
+ *   extraRegistrations: (container) => {
+ *     // Register your custom services
+ *     container.register({
+ *       myService: asClass(MyService).singleton(),
+ *     })
+ *   },
+ * })
+ * ```
+ */
+declare const createKuckitContainer: (opts: CreateKuckitOptions) => Promise<CoreContainer>;
+/**
+ * Cleanup container resources gracefully
+ *
+ * Call this when shutting down your application to close database connections
+ * and other resources.
+ */
+declare const disposeContainer: (container: CoreContainer) => Promise<void>;
+//#endregion
+export { createKuckitContainer as n, disposeContainer as r, CreateKuckitOptions as t };
+//# sourceMappingURL=container-Ngzcb6LI.d.ts.map

package/dist/core/container.d.ts

@@ -0,0 +1,3 @@
+import "../types-DKCy16X1.js";
+import { n as createKuckitContainer, r as disposeContainer, t as CreateKuckitOptions } from "../container-Ngzcb6LI.js";
+export { CreateKuckitOptions, createKuckitContainer, disposeContainer };

package/dist/core/container.js

@@ -0,0 +1,4 @@
+import "../core.module-Ctm2stcL.js";
+import { n as disposeContainer, t as createKuckitContainer } from "../container-D0DK003A.js";
+
+export { createKuckitContainer, disposeContainer };

package/dist/core/core.module.d.ts

@@ -0,0 +1,3 @@
+import "../types-DKCy16X1.js";
+import { t as registerCoreModule } from "../core.module-Ckt9iPWn.js";
+export { registerCoreModule };

package/dist/core/core.module.js

@@ -0,0 +1,3 @@
+import { t as registerCoreModule } from "../core.module-Ctm2stcL.js";
+
+export { registerCoreModule };

package/dist/core.module-Ckt9iPWn.d.ts

@@ -0,0 +1,22 @@
+import { n as CoreContainer } from "./types-DKCy16X1.js";
+
+//#region src/core/core.module.d.ts
+
+/**
+ * Register core infrastructure services into the container
+ *
+ * This registers:
+ * - Database pool and connection
+ * - Clock
+ * - Logger (structured, Loki/Prometheus compatible)
+ * - AI provider
+ * - Auth
+ * - Event bus
+ * - Cache store
+ * - Rate limiter store
+ * - Request-scoped logger
+ */
+declare const registerCoreModule: (container: CoreContainer) => void;
+//#endregion
+export { registerCoreModule as t };
+//# sourceMappingURL=core.module-Ckt9iPWn.d.ts.map

package/dist/core.module-Ctm2stcL.js

@@ -0,0 +1,48 @@
+import { asClass, asFunction, asValue } from "awilix";
+import { SystemClock } from "@kuckit/domain";
+import { google } from "@ai-sdk/google";
+import { auth } from "@kuckit/auth";
+import { InMemoryCacheStore, InMemoryEventBus, InMemoryRateLimiterStore, createDb, createDbPool, makeErrorHandler, makeRequestLogger, makeStructuredLogger } from "@kuckit/infrastructure";
+
+//#region src/core/core.module.ts
+/**
+* Register core infrastructure services into the container
+*
+* This registers:
+* - Database pool and connection
+* - Clock
+* - Logger (structured, Loki/Prometheus compatible)
+* - AI provider
+* - Auth
+* - Event bus
+* - Cache store
+* - Rate limiter store
+* - Request-scoped logger
+*/
+const registerCoreModule = (container) => {
+	container.register({
+		dbPool: asFunction(({ config }) => createDbPool(config.databaseUrl)).singleton(),
+		db: asFunction(({ dbPool }) => createDb(dbPool)).singleton(),
+		clock: asValue(new SystemClock()),
+		logger: asFunction(({ config }) => makeStructuredLogger({
+			enableFile: config.enableFileLogging,
+			logDir: config.logDir,
+			minLevel: config.logLevel
+		})).singleton(),
+		errorHandler: asFunction(({ logger }) => makeErrorHandler(logger)).singleton(),
+		auth: asValue(auth),
+		aiProvider: asFunction(() => google("gemini-2.5-flash")).singleton(),
+		eventBus: asFunction(({ logger }) => new InMemoryEventBus(logger)).singleton(),
+		cacheStore: asClass(InMemoryCacheStore).singleton(),
+		rateLimiterStore: asClass(InMemoryRateLimiterStore).singleton(),
+		requestLogger: asFunction(({ logger, requestId, session }) => makeRequestLogger({
+			requestId,
+			userId: session?.user?.id,
+			baseLogger: logger
+		})).scoped()
+	});
+};
+
+//#endregion
+export { registerCoreModule as t };
+//# sourceMappingURL=core.module-Ctm2stcL.js.map

package/dist/core.module-Ctm2stcL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.module-Ctm2stcL.js","names":[],"sources":["../src/core/core.module.ts"],"sourcesContent":["import { asClass, asFunction, asValue } from 'awilix'\nimport { SystemClock } from '@kuckit/domain'\nimport { google } from '@ai-sdk/google'\nimport { auth } from '@kuckit/auth'\nimport {\n\tcreateDbPool,\n\tcreateDb,\n\tmakeStructuredLogger,\n\tmakeRequestLogger,\n\tmakeErrorHandler,\n\tInMemoryEventBus,\n\tInMemoryCacheStore,\n\tInMemoryRateLimiterStore,\n} from '@kuckit/infrastructure'\nimport type { CoreContainer } from '../types'\n\n/**\n * Register core infrastructure services into the container\n *\n * This registers:\n * - Database pool and connection\n * - Clock\n * - Logger (structured, Loki/Prometheus compatible)\n * - AI provider\n * - Auth\n * - Event bus\n * - Cache store\n * - Rate limiter store\n * - Request-scoped logger\n */\nexport const registerCoreModule = (container: CoreContainer): void => {\n\tcontainer.register({\n\t\t// Database\n\t\tdbPool: asFunction(({ config }) => createDbPool(config.databaseUrl)).singleton(),\n\t\tdb: asFunction(({ dbPool }) => createDb(dbPool)).singleton(),\n\n\t\t// Core services\n\t\tclock: asValue(new SystemClock()),\n\n\t\tlogger: asFunction(({ config }) =>\n\t\t\tmakeStructuredLogger({\n\t\t\t\tenableFile: config.enableFileLogging,\n\t\t\t\tlogDir: config.logDir,\n\t\t\t\tminLevel: config.logLevel,\n\t\t\t})\n\t\t).singleton(),\n\n\t\terrorHandler: asFunction(({ logger }) => makeErrorHandler(logger)).singleton(),\n\n\t\t// External integrations\n\t\tauth: asValue(auth),\n\t\taiProvider: asFunction(() => google('gemini-2.5-flash')).singleton(),\n\n\t\t// Event bus\n\t\teventBus: asFunction(({ logger }) => new InMemoryEventBus(logger)).singleton(),\n\n\t\t// Stores\n\t\tcacheStore: asClass(InMemoryCacheStore).singleton(),\n\t\trateLimiterStore: asClass(InMemoryRateLimiterStore).singleton(),\n\n\t\t// Request-scoped logger (enriched with requestId and userId)\n\t\trequestLogger: asFunction(({ logger, requestId, session }) =>\n\t\t\tmakeRequestLogger({\n\t\t\t\trequestId,\n\t\t\t\tuserId: session?.user?.id,\n\t\t\t\tbaseLogger: logger,\n\t\t\t})\n\t\t).scoped(),\n\t})\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,sBAAsB,cAAmC;AACrE,WAAU,SAAS;EAElB,QAAQ,YAAY,EAAE,aAAa,aAAa,OAAO,YAAY,CAAC,CAAC,WAAW;EAChF,IAAI,YAAY,EAAE,aAAa,SAAS,OAAO,CAAC,CAAC,WAAW;EAG5D,OAAO,QAAQ,IAAI,aAAa,CAAC;EAEjC,QAAQ,YAAY,EAAE,aACrB,qBAAqB;GACpB,YAAY,OAAO;GACnB,QAAQ,OAAO;GACf,UAAU,OAAO;GACjB,CAAC,CACF,CAAC,WAAW;EAEb,cAAc,YAAY,EAAE,aAAa,iBAAiB,OAAO,CAAC,CAAC,WAAW;EAG9E,MAAM,QAAQ,KAAK;EACnB,YAAY,iBAAiB,OAAO,mBAAmB,CAAC,CAAC,WAAW;EAGpE,UAAU,YAAY,EAAE,aAAa,IAAI,iBAAiB,OAAO,CAAC,CAAC,WAAW;EAG9E,YAAY,QAAQ,mBAAmB,CAAC,WAAW;EACnD,kBAAkB,QAAQ,yBAAyB,CAAC,WAAW;EAG/D,eAAe,YAAY,EAAE,QAAQ,WAAW,cAC/C,kBAAkB;GACjB;GACA,QAAQ,SAAS,MAAM;GACvB,YAAY;GACZ,CAAC,CACF,CAAC,QAAQ;EACV,CAAC"}

package/dist/define-config-GYI_W9K6.js

@@ -0,0 +1,34 @@
+//#region src/config/define-config.ts
+/**
+* Define a Kuckit configuration with full type safety.
+*
+* This helper provides IntelliSense support and type checking for your configuration.
+*
+* @example
+* ```typescript
+* // kuckit.config.ts
+* import { defineConfig } from '@kuckit/sdk'
+*
+* export default defineConfig({
+*   modules: [
+*     { package: '@kuckit/users-module' },
+*     { package: '@acme/billing-module', config: { currency: 'USD' } },
+*   ],
+*
+*   server: {
+*     apiPrefix: '/api',
+*   },
+*
+*   client: {
+*     routeInjection: true,
+*   },
+* })
+* ```
+*/
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineConfig as t };
+//# sourceMappingURL=define-config-GYI_W9K6.js.map

package/dist/define-config-GYI_W9K6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-config-GYI_W9K6.js","names":[],"sources":["../src/config/define-config.ts"],"sourcesContent":["import type { KuckitConfig } from './types'\n\n/**\n * Define a Kuckit configuration with full type safety.\n *\n * This helper provides IntelliSense support and type checking for your configuration.\n *\n * @example\n * ```typescript\n * // kuckit.config.ts\n * import { defineConfig } from '@kuckit/sdk'\n *\n * export default defineConfig({\n *   modules: [\n *     { package: '@kuckit/users-module' },\n *     { package: '@acme/billing-module', config: { currency: 'USD' } },\n *   ],\n *\n *   server: {\n *     apiPrefix: '/api',\n *   },\n *\n *   client: {\n *     routeInjection: true,\n *   },\n * })\n * ```\n */\nexport function defineConfig(config: KuckitConfig): KuckitConfig {\n\treturn config\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,aAAa,QAAoC;AAChE,QAAO"}

package/dist/define-config-yzb59aTs.d.ts

@@ -0,0 +1,34 @@
+import { n as KuckitConfig } from "./types-DxaDmkQo.js";
+
+//#region src/config/define-config.d.ts
+
+/**
+ * Define a Kuckit configuration with full type safety.
+ *
+ * This helper provides IntelliSense support and type checking for your configuration.
+ *
+ * @example
+ * ```typescript
+ * // kuckit.config.ts
+ * import { defineConfig } from '@kuckit/sdk'
+ *
+ * export default defineConfig({
+ *   modules: [
+ *     { package: '@kuckit/users-module' },
+ *     { package: '@acme/billing-module', config: { currency: 'USD' } },
+ *   ],
+ *
+ *   server: {
+ *     apiPrefix: '/api',
+ *   },
+ *
+ *   client: {
+ *     routeInjection: true,
+ *   },
+ * })
+ * ```
+ */
+declare function defineConfig(config: KuckitConfig): KuckitConfig;
+//#endregion
+export { defineConfig as t };
+//# sourceMappingURL=define-config-yzb59aTs.d.ts.map

package/dist/define-module-B83hUzJz.js

@@ -0,0 +1,58 @@
+//#region src/modules/define-module.ts
+/**
+* Helper to define a Kuckit module with type safety
+*
+* This is the primary way to create a module for the Kuckit SDK.
+* It provides type inference for the configuration and validates
+* the module structure at compile time.
+*
+* @example
+* ```ts
+* // In your module's main file (e.g., src/module.ts)
+* import { defineKuckitModule, asClass, asFunction } from '@kuckit/sdk'
+*
+* interface BillingModuleConfig {
+*   currency: string
+*   taxRate: number
+* }
+*
+* export const kuckitModule = defineKuckitModule<BillingModuleConfig>({
+*   id: 'acme.billing',
+*   displayName: 'Billing',
+*   description: 'Invoice and payment processing',
+*   version: '1.0.0',
+*
+*   register(ctx) {
+*     ctx.container.register({
+*       invoiceRepository: asClass(DrizzleInvoiceRepository).scoped(),
+*       paymentService: asFunction(makePaymentService).singleton(),
+*     })
+*   },
+*
+*   registerApi(ctx) {
+*     ctx.addApiRegistration({
+*       type: 'rpc-router',
+*       name: 'billing',
+*       router: createBillingRouter(ctx.container),
+*     })
+*   },
+*
+*   onBootstrap(ctx) {
+*     const logger = ctx.container.resolve('logger')
+*     logger.info(`Billing module initialized with currency: ${ctx.config.currency}`)
+*   },
+* })
+* ```
+*
+* @param mod - The module definition object
+* @returns The same module definition (for type inference)
+*/
+const defineKuckitModule = (mod) => {
+	if (!mod.id) throw new Error("Module must have an id");
+	if (typeof mod.id !== "string" || mod.id.trim() === "") throw new Error("Module id must be a non-empty string");
+	return mod;
+};
+
+//#endregion
+export { defineKuckitModule as t };
+//# sourceMappingURL=define-module-B83hUzJz.js.map

package/dist/define-module-B83hUzJz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-module-B83hUzJz.js","names":[],"sources":["../src/modules/define-module.ts"],"sourcesContent":["import type { KuckitModuleDefinition } from './types'\n\n/**\n * Helper to define a Kuckit module with type safety\n *\n * This is the primary way to create a module for the Kuckit SDK.\n * It provides type inference for the configuration and validates\n * the module structure at compile time.\n *\n * @example\n * ```ts\n * // In your module's main file (e.g., src/module.ts)\n * import { defineKuckitModule, asClass, asFunction } from '@kuckit/sdk'\n *\n * interface BillingModuleConfig {\n *   currency: string\n *   taxRate: number\n * }\n *\n * export const kuckitModule = defineKuckitModule<BillingModuleConfig>({\n *   id: 'acme.billing',\n *   displayName: 'Billing',\n *   description: 'Invoice and payment processing',\n *   version: '1.0.0',\n *\n *   register(ctx) {\n *     ctx.container.register({\n *       invoiceRepository: asClass(DrizzleInvoiceRepository).scoped(),\n *       paymentService: asFunction(makePaymentService).singleton(),\n *     })\n *   },\n *\n *   registerApi(ctx) {\n *     ctx.addApiRegistration({\n *       type: 'rpc-router',\n *       name: 'billing',\n *       router: createBillingRouter(ctx.container),\n *     })\n *   },\n *\n *   onBootstrap(ctx) {\n *     const logger = ctx.container.resolve('logger')\n *     logger.info(`Billing module initialized with currency: ${ctx.config.currency}`)\n *   },\n * })\n * ```\n *\n * @param mod - The module definition object\n * @returns The same module definition (for type inference)\n */\nexport const defineKuckitModule = <TConfig = unknown>(\n\tmod: KuckitModuleDefinition<TConfig>\n): KuckitModuleDefinition<TConfig> => {\n\t// Validate required fields\n\tif (!mod.id) {\n\t\tthrow new Error('Module must have an id')\n\t}\n\n\tif (typeof mod.id !== 'string' || mod.id.trim() === '') {\n\t\tthrow new Error('Module id must be a non-empty string')\n\t}\n\n\treturn mod\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,MAAa,sBACZ,QACqC;AAErC,KAAI,CAAC,IAAI,GACR,OAAM,IAAI,MAAM,yBAAyB;AAG1C,KAAI,OAAO,IAAI,OAAO,YAAY,IAAI,GAAG,MAAM,KAAK,GACnD,OAAM,IAAI,MAAM,uCAAuC;AAGxD,QAAO"}

package/dist/define-module-Cw7q13EE.d.ts

@@ -0,0 +1,56 @@
+import { i as KuckitModuleDefinition } from "./types-ByO301S-.js";
+
+//#region src/modules/define-module.d.ts
+
+/**
+ * Helper to define a Kuckit module with type safety
+ *
+ * This is the primary way to create a module for the Kuckit SDK.
+ * It provides type inference for the configuration and validates
+ * the module structure at compile time.
+ *
+ * @example
+ * ```ts
+ * // In your module's main file (e.g., src/module.ts)
+ * import { defineKuckitModule, asClass, asFunction } from '@kuckit/sdk'
+ *
+ * interface BillingModuleConfig {
+ *   currency: string
+ *   taxRate: number
+ * }
+ *
+ * export const kuckitModule = defineKuckitModule<BillingModuleConfig>({
+ *   id: 'acme.billing',
+ *   displayName: 'Billing',
+ *   description: 'Invoice and payment processing',
+ *   version: '1.0.0',
+ *
+ *   register(ctx) {
+ *     ctx.container.register({
+ *       invoiceRepository: asClass(DrizzleInvoiceRepository).scoped(),
+ *       paymentService: asFunction(makePaymentService).singleton(),
+ *     })
+ *   },
+ *
+ *   registerApi(ctx) {
+ *     ctx.addApiRegistration({
+ *       type: 'rpc-router',
+ *       name: 'billing',
+ *       router: createBillingRouter(ctx.container),
+ *     })
+ *   },
+ *
+ *   onBootstrap(ctx) {
+ *     const logger = ctx.container.resolve('logger')
+ *     logger.info(`Billing module initialized with currency: ${ctx.config.currency}`)
+ *   },
+ * })
+ * ```
+ *
+ * @param mod - The module definition object
+ * @returns The same module definition (for type inference)
+ */
+declare const defineKuckitModule: <TConfig = unknown>(mod: KuckitModuleDefinition<TConfig>) => KuckitModuleDefinition<TConfig>;
+//#endregion
+export { defineKuckitModule as t };
+//# sourceMappingURL=define-module-Cw7q13EE.d.ts.map

package/dist/index-CDDzqahH.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/index-Dfcz46Ma.d.ts

@@ -0,0 +1,2 @@
+import { PgTable as PgTable$1 } from "drizzle-orm/pg-core";
+export { PgTable$1 as t };

package/dist/index-Dw5cCt-A.d.ts

@@ -0,0 +1 @@
+export { };