@cldmv/slothlet 3.2.3 → 3.3.2

package/types/dist/lib/i18n/translations.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"translations.d.mts","sourceRoot":"","sources":["../../../../dist/lib/i18n/translations.mjs"],"names":[],"mappings":"AAuFA;;;;;GAKG;AACH,kCAHW,MAAM,QAsBhB;AAED;;;;GAIG;AACH,+BAHa,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,qCALW,MAAM,iBAEJ,MAAM,CAyBlB;AAED;;;;;GAKG;AACH,mCAHG;IAAyB,QAAQ,GAAzB,MAAM;CACd,QAiBF;AApDD;;;;;;GAMG;AACH,6BALW,MAAM,iBAEJ,MAAM,CAyBlB"}
+{"version":3,"file":"translations.d.mts","sourceRoot":"","sources":["../../../../dist/lib/i18n/translations.mjs"],"names":[],"mappings":"AAA4wC,sCAA8C;AAAmc,6CAAgU;AAA/rC,6CAA8Y;AAA8C,oDAAmc;AAAnc,4DAAmc"}

package/types/dist/lib/modes/eager.d.mts

@@ -1,35 +1,13 @@
-/**
- * Eager mode component - builds APIs by loading all modules immediately.
- * @class EagerMode
- * @extends ComponentBase
- * @package
- */
 export class EagerMode extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Build API in eager mode (load all modules immediately).
-     * @param {Object} options - Build options
-     * @param {string} options.dir - Directory path to load from
-     * @param {string} [options.apiPathPrefix=""] - Prefix for API paths
-     * @param {string} [options.collisionContext="initial"] - Collision context
-     * @param {string} [options.moduleID] - Module ID
-     * @param {number} [options.apiDepth=Infinity] - Maximum directory depth
-     * @param {string|null} [options.cacheBust=null] - Cache-busting value
-     * @param {Function|null} [options.fileFilter=null] - Optional filter (fileName) => boolean
-     * @returns {Promise<Object>} Built API object
-     * @public
-     *
-     * @example
-     * const api = await slothlet.modes.eager.buildAPI({ dir: "./api", moduleID: "base" });
-     */
-    public buildAPI({ dir, apiPathPrefix, collisionContext, moduleID, apiDepth, cacheBust, fileFilter }: {
-        dir: string;
-        apiPathPrefix?: string;
-        collisionContext?: string;
-        moduleID?: string;
-        apiDepth?: number;
-        cacheBust?: string | null;
-        fileFilter?: Function | null;
+    buildAPI({ dir, apiPathPrefix, collisionContext, moduleID, apiDepth, cacheBust, fileFilter }: {
+        dir: any;
+        apiPathPrefix?: string | undefined;
+        collisionContext?: string | undefined;
+        moduleID: any;
+        apiDepth?: number | undefined;
+        cacheBust?: null | undefined;
+        fileFilter?: null | undefined;
     }): Promise<any>;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/types/dist/lib/modes/eager.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/eager.mjs"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH;IACC,gCAAkC;IAWlC;;;;;;;;;;;;;;;OAeG;IACH,qGAbG;QAAwB,GAAG,EAAnB,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,gBAAgB,GAAjC,MAAM;QACW,QAAQ,GAAzB,MAAM;QACW,QAAQ,GAAzB,MAAM;QACgB,SAAS,GAA/B,MAAM,GAAC,IAAI;QACa,UAAU,GAAlC,WAAS,IAAI;KACrB,GAAU,OAAO,KAAQ,CAgD3B;CACD;8BA/E6B,0CAA0C"}
+{"version":3,"file":"eager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/eager.mjs"],"names":[],"mappings":"AAAoE;IAAsC,gCAAgC;IAAsC;;;;;;;;qBAAkpB;CAAC;8BAA1yB,0CAA0C"}

package/types/dist/lib/modes/lazy.d.mts

@@ -1,48 +1,15 @@
-/**
- * Lazy mode component - builds APIs with deferred (on-demand) loading.
- * @class LazyMode
- * @extends ComponentBase
- * @package
- */
 export class LazyMode extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Create a named async materialization function for lazy subdirectories.
-     * @param {string} apiPath - API path to derive the function name from.
-     * @param {Function} handler - Async handler that performs materialization.
-     * @returns {Function} Named async materialization function.
-     * @public
-     *
-     * @example
-     * const fn = lazyMode.createNamedMaterializeFunc('api.math', async () => ({ add: (a,b) => a+b }));
-     */
-    public createNamedMaterializeFunc(apiPath: string, handler: Function): Function;
-    /**
-     * Build API in lazy mode (proxy-based deferred loading).
-     * @param {Object} options - Build options
-     * @param {string} options.dir - Directory to build from
-     * @param {string} [options.apiPathPrefix=""] - Prefix for API paths
-     * @param {string} [options.collisionContext="initial"] - Collision context
-     * @param {string|null} [options.collisionMode=null] - Collision mode override from api.add()
-     * @param {string} [options.moduleID] - Module ID
-     * @param {number} [options.apiDepth=Infinity] - Maximum directory depth
-     * @param {string|null} [options.cacheBust=null] - Cache-busting value
-     * @param {Function|null} [options.fileFilter=null] - Optional filter (fileName) => boolean
-     * @returns {Promise<Object>} Built API object with lazy proxies
-     * @public
-     *
-     * @example
-     * const api = await slothlet.modes.lazy.buildAPI({ dir: "./api", moduleID: "base" });
-     */
-    public buildAPI({ dir, apiPathPrefix, collisionContext, collisionMode, moduleID, apiDepth, cacheBust, fileFilter }: {
-        dir: string;
-        apiPathPrefix?: string;
-        collisionContext?: string;
-        collisionMode?: string | null;
-        moduleID?: string;
-        apiDepth?: number;
-        cacheBust?: string | null;
-        fileFilter?: Function | null;
+    createNamedMaterializeFunc(apiPath: any, handler: any): (...args: any[]) => Promise<any>;
+    buildAPI({ dir, apiPathPrefix, collisionContext, collisionMode, moduleID, apiDepth, cacheBust, fileFilter }: {
+        dir: any;
+        apiPathPrefix?: string | undefined;
+        collisionContext?: string | undefined;
+        collisionMode?: null | undefined;
+        moduleID: any;
+        apiDepth?: number | undefined;
+        cacheBust?: null | undefined;
+        fileFilter?: null | undefined;
     }): Promise<any>;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/types/dist/lib/modes/lazy.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/lazy.mjs"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH;IACC,gCAAiC;IAWjC;;;;;;;;;OASG;IACH,2CARW,MAAM,+BAmBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,oHAdG;QAAwB,GAAG,EAAnB,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,gBAAgB,GAAjC,MAAM;QACgB,aAAa,GAAnC,MAAM,GAAC,IAAI;QACM,QAAQ,GAAzB,MAAM;QACW,QAAQ,GAAzB,MAAM;QACgB,SAAS,GAA/B,MAAM,GAAC,IAAI;QACa,UAAU,GAAlC,WAAS,IAAI;KACrB,GAAU,OAAO,KAAQ,CAwD3B;CACD;8BA/G6B,0CAA0C"}
+{"version":3,"file":"lazy.d.mts","sourceRoot":"","sources":["../../../../dist/lib/modes/lazy.mjs"],"names":[],"mappings":"AAAoE;IAAqC,gCAA+B;IAAsC,yFAAiV;IAAA;;;;;;;;;qBAAqyB;CAAC;8BAA5wC,0CAA0C"}

package/types/dist/lib/processors/flatten.d.mts

@@ -1,113 +1,62 @@
-/**
- * Flattening decision processor
- * @class Flatten
- * @extends ComponentBase
- * @package
- */
 export class Flatten extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Core flattening decision function.
-     * Implements conditions C01-C07 from getFlatteningDecision().
-     * @param {object} options - Decision options
-     * @param {object} options.mod - Module exports
-     * @param {string} options.moduleName - Sanitized module name
-     * @param {string} options.categoryName - Category/folder name
-     * @param {object} options.analysis - Export analysis
-     * @param {boolean} options.hasMultipleDefaults - Multiple defaults in folder
-     * @param {array} options.moduleKeys - Keys from module
-     * @param {function} options.t - Translation function
-     * @returns {Promise<object>} Flattening decision
-     * @public
-     */
-    public getFlatteningDecision(options: {
-        mod: object;
-        moduleName: string;
-        categoryName: string;
-        analysis: object;
-        hasMultipleDefaults: boolean;
-        moduleKeys: any[];
-        t: Function;
-    }): Promise<object>;
-    /**
-     * Build module content for API assignment.
-     *
-     * Canonical implementation of the C08-C09b content-building rules, including
-     * AddApi detection and collision handling. Previously this logic was inlined
-     * inside modes-processor.mjs; it now lives here so the processor stays focused
-     * on wrapping and assignment concerns only.
-     *
-     * Collision config, modesUtils helpers, and SlothletWarning are accessed
-     * directly through {@link this.slothlet} / {@link this.slothlet.config} — no caller
-     * plumbing required.
-     *
-     * @param {object}   options                              - Processing options.
-     * @param {object}   options.mod                         - Module exports.
-     * @param {object}   options.decision                    - Flattening decision from getFlatteningDecision.
-     * @param {string}   options.moduleName                  - Sanitized module name (used for C08 auto-flatten key lookup).
-     * @param {string}   options.propertyName                - Resolved preferred name (decision.preferredName || moduleName).
-     * @param {string[]} options.moduleKeys                  - Named export keys (excluding "default").
-     * @param {object}   options.analysis                    - { hasDefault, hasNamed, defaultExportType }.
-     * @param {object}   [options.file=null]                 - File descriptor for AddApi detection via file.name / file.fullName.
-     * @param {string}   [options.collisionContext="initial"] - Collision context ("initial" | "api").
-     * @param {string}   [options.apiPathPrefix=""]          - API path prefix for collision error messages.
-     * @returns {{ moduleContent: object|Function }} Built module content ready for wrapping/assignment.
-     * @public
-     */
-    public processModuleForAPI(options: {
-        mod: object;
-        decision: object;
-        moduleName: string;
-        propertyName: string;
-        moduleKeys: string[];
-        analysis: object;
-        file?: object;
-        collisionContext?: string;
-        apiPathPrefix?: string;
-    }): {
-        moduleContent: object | Function;
+    getFlatteningDecision(options: any): Promise<{
+        preserveAsNamespace: boolean;
+        reason: any;
+        flattenToRoot?: undefined;
+    } | {
+        flattenToRoot: boolean;
+        reason: any;
+        preserveAsNamespace?: undefined;
+    } | {
+        flattenToCategory: boolean;
+        flattenType: string;
+        reason: any;
+        useAutoFlattening?: undefined;
+        preserveAsNamespace?: undefined;
+        preferredName?: undefined;
+    } | {
+        useAutoFlattening: boolean;
+        reason: any;
+        flattenToCategory?: undefined;
+        flattenType?: undefined;
+        preserveAsNamespace?: undefined;
+        preferredName?: undefined;
+    } | {
+        flattenToCategory: boolean;
+        reason: any;
+        flattenType?: undefined;
+        useAutoFlattening?: undefined;
+        preserveAsNamespace?: undefined;
+        preferredName?: undefined;
+    } | {
+        preserveAsNamespace: boolean;
+        preferredName: any;
+        reason: any;
+        flattenToCategory?: undefined;
+        flattenType?: undefined;
+        useAutoFlattening?: undefined;
+    }>;
+    processModuleForAPI(options: any): {
+        moduleContent: any;
     };
-    /**
-     * Build category-level flattening decisions.
-     * Implements conditions C10-C33 from buildCategoryDecisions().
-     * @param {object} options - Category options
-     * @param {string} options.categoryName - Category name
-     * @param {object} options.mod - Module exports
-     * @param {string} options.moduleName - Module name
-     * @param {string} options.fileBaseName - File base name
-     * @param {object} options.analysis - Export analysis
-     * @param {array} options.moduleKeys - Module keys
-     * @param {number} options.currentDepth - Current depth
-     * @param {array} options.moduleFiles - Files in category
-     * @param {function} options.t - Translation function
-     * @returns {Promise<object>} Category decision
-     * @public
-     */
-    public buildCategoryDecisions(options: {
-        categoryName: string;
-        mod: object;
-        moduleName: string;
-        fileBaseName: string;
-        analysis: object;
-        moduleKeys: any[];
-        currentDepth: number;
-        moduleFiles: any[];
-        t: Function;
-    }): Promise<object>;
-    /**
-     * Decide whether a named export should be attached to a callable default export.
-     *
-     * Returns false when the named export is the same reference as the default (re-export
-     * pattern), or when the export key matches the function name (self-referential export).
-     *
-     * @param {string} key - Named export key.
-     * @param {unknown} value - Named export value.
-     * @param {Function} defaultFunc - Wrapped callable default export.
-     * @param {Function} originalDefault - Original default export.
-     * @returns {boolean} True if the export should be attached.
-     * @public
-     */
-    public shouldAttachNamedExport(key: string, value: unknown, defaultFunc: Function, originalDefault: Function): boolean;
+    buildCategoryDecisions(options: any): Promise<{
+        shouldFlatten: boolean;
+        flattenType: string;
+        reason: any;
+        preferredName?: undefined;
+    } | {
+        shouldFlatten: boolean;
+        flattenType: string;
+        preferredName: any;
+        reason: any;
+    } | {
+        shouldFlatten: boolean;
+        preferredName: any;
+        reason: any;
+        flattenType?: undefined;
+    }>;
+    shouldAttachNamedExport(key: any, value: any, defaultFunc: any, originalDefault: any): boolean;
     #private;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/types/dist/lib/processors/flatten.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"flatten.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/flatten.mjs"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH;IACC,gCAAoC;IAgEpC;;;;;;;;;;;;;OAaG;IACH,sCAVG;QAAwB,GAAG,EAAnB,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,QAAQ,EAAxB,MAAM;QACW,mBAAmB,EAApC,OAAO;QACQ,UAAU;QACP,CAAC;KAC3B,GAAU,OAAO,CAAC,MAAM,CAAC,CAiG3B;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,oCAZG;QAA0B,GAAG,EAArB,MAAM;QACY,QAAQ,EAA1B,MAAM;QACY,UAAU,EAA5B,MAAM;QACY,YAAY,EAA9B,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACU,QAAQ,EAA1B,MAAM;QACa,IAAI,GAAvB,MAAM;QACa,gBAAgB,GAAnC,MAAM;QACa,aAAa,GAAhC,MAAM;KACd,GAAU;QAAE,aAAa,EAAE,MAAM,WAAS,CAAA;KAAE,CAqI9C;IAED;;;;;;;;;;;;;;;OAeG;IACH,uCAZG;QAAwB,YAAY,EAA5B,MAAM;QACU,GAAG,EAAnB,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,QAAQ,EAAxB,MAAM;QACS,UAAU;QACT,YAAY,EAA5B,MAAM;QACS,WAAW;QACR,CAAC;KAC3B,GAAU,OAAO,CAAC,MAAM,CAAC,CAiJ3B;IAED;;;;;;;;;;;;OAYG;IACH,oCAPW,MAAM,SACN,OAAO,qDAGL,OAAO,CAiBnB;;CACD;8BAhhB6B,0CAA0C"}
+{"version":3,"file":"flatten.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/flatten.mjs"],"names":[],"mappings":"AAAoE;IAAoC,gCAAkC;IAAqjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA8pE;IAAA;;MAA+yF;IAAA;;;;;;;;;;;;;;;OAAk7G;IAAA,+FAA0U;;CAAC;8BAAh3S,0CAA0C"}

package/types/dist/lib/processors/loader.d.mts

@@ -1,46 +1,11 @@
-/**
- * Loader component for module loading, directory scanning, and API merging
- * @class Loader
- * @extends ComponentBase
- * @package
- */
 export class Loader extends ComponentBase {
     static slothletProperty: string;
-    constructor(slothlet: any);
-    /**
-     * Load a single module
-     * @param {string} filePath - Path to module file
-     * @param {string} [instanceID] - Slothlet instance ID for cache busting
-     * @param {string} [moduleID] - Module ID for additional cache busting (used in api.slothlet.api.add)
-     * @param {number|null} [cacheBust=null] - Timestamp for reload cache busting (forces fresh import)
-     * @returns {Promise<Object>} Loaded module
-     * @public
-     */
-    public loadModule(filePath: string, instanceID?: string, moduleID?: string, cacheBust?: number | null): Promise<any>;
-    /**
-     * Scan directory for module files
-     * @param {string} dir - Directory to scan
-     * @param {Object} [options={}] - Scan options
-     * @param {boolean} [options.isRootScan=true] - Whether this is the root directory scan (shows empty dir warning)
-     * @param {number} [options.currentDepth=0] - Current traversal depth
-     * @param {number} [options.maxDepth=Infinity] - Maximum traversal depth
-     * @param {Function|null} [options.fileFilter=null] - Optional filter function (fileName) => boolean to load specific files only
-     * @returns {Promise<Object>} Directory structure
-     * @public
-     */
-    public scanDirectory(dir: string, options?: {
-        isRootScan?: boolean;
-        currentDepth?: number;
-        maxDepth?: number;
-        fileFilter?: Function | null;
-    }): Promise<any>;
-    /**
-     * Extract exports from module
-     * @param {Object} module - Loaded module
-     * @returns {Object} Extracted exports
-     * @public
-     */
-    public extractExports(module: any): any;
+    loadModule(filePath: any, instanceID: any, moduleID: any, cacheBust?: null): Promise<any>;
+    scanDirectory(dir: any, options?: {}): Promise<{
+        files: never[];
+        directories: never[];
+    }>;
+    extractExports(module: any): {};
     #private;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/types/dist/lib/processors/loader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/loader.mjs"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH;IACC,gCAAmC;IAEnC,2BAEC;IAED;;;;;;;;OAQG;IACH,4BAPW,MAAM,eACN,MAAM,aACN,MAAM,cACN,MAAM,GAAC,IAAI,GACT,OAAO,KAAQ,CAwK3B;IAuCD;;;;;;;;;;OAUG;IACH,0BATW,MAAM,YAEd;QAA0B,UAAU,GAA5B,OAAO;QACU,YAAY,GAA7B,MAAM;QACW,QAAQ,GAAzB,MAAM;QACkB,UAAU,GAAlC,WAAS,IAAI;KACrB,GAAU,OAAO,KAAQ,CA0F3B;IAED;;;;;OAKG;IACH,wCAoCC;;CACD;8BAnX6B,0CAA0C"}
+{"version":3,"file":"loader.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/loader.mjs"],"names":[],"mappings":"AAA+O;IAAmC,gCAAiC;IAAsC,0FAA2nG;IAA4Y;;;OAA+7C;IAAA,gCAAipB;;CAAC;8BAA7uL,0CAA0C"}

package/types/dist/lib/processors/type-generator.d.mts

@@ -1,19 +1,5 @@
-/**
- * Generate TypeScript declaration file for a Slothlet API
- * @param {object} api - The loaded Slothlet API
- * @param {object} options - Generation options
- * @param {string} options.output - Output file path for .d.ts
- * @param {string} options.interfaceName - Name of the interface to generate
- * @param {boolean} [options.includeDocumentation=true] - Include JSDoc comments
- * @returns {Promise<{output: string, filePath: string}>} Generated declaration and output path
- * @public
- */
-export function generateTypes(api: object, options: {
+export function generateTypes(api: any, options: any): Promise<{
     output: string;
-    interfaceName: string;
-    includeDocumentation?: boolean;
-}): Promise<{
-    output: string;
-    filePath: string;
+    filePath: any;
 }>;
 //# sourceMappingURL=type-generator.d.mts.map

package/types/dist/lib/processors/type-generator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"type-generator.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/type-generator.mjs"],"names":[],"mappings":"AA8CA;;;;;;;;;GASG;AACH,mCARW,MAAM,WAEd;IAAwB,MAAM,EAAtB,MAAM;IACU,aAAa,EAA7B,MAAM;IACY,oBAAoB,GAAtC,OAAO;CACf,GAAU,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAC,CAqDvD"}
+{"version":3,"file":"type-generator.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/type-generator.mjs"],"names":[],"mappings":"AAA+V;;;GAAwiC"}

package/types/dist/lib/processors/typescript.d.mts

@@ -1,55 +1,8 @@
-/**
- * Transform TypeScript code to JavaScript using esbuild
- * @param {string} filePath - Path to the TypeScript file
- * @param {object} [options={}] - esbuild transform options
- * @param {string} [options.target] - ECMAScript target version (default: "es2020")
- * @param {string} [options.format] - Module format (default: "esm")
- * @param {boolean} [options.sourcemap] - Generate source maps (default: false)
- * @returns {Promise<string>} Transformed JavaScript code
- * @throws {SlothletError} If transformation fails
- * @public
- */
-export function transformTypeScript(filePath: string, options?: {
-    target?: string;
-    format?: string;
-    sourcemap?: boolean;
-}): Promise<string>;
-/**
- * Create a data URL for dynamic import with cache busting
- * @param {string} code - JavaScript code to encode
- * @returns {string} Data URL suitable for dynamic import
- * @public
- */
-export function createDataUrl(code: string): string;
-/**
- * Transform TypeScript code to JavaScript using tsc with type checking
- * @param {string} filePath - Path to the TypeScript file
- * @param {object} [options={}] - TypeScript compiler options
- * @param {string} [options.target] - ECMAScript target version (default: "ES2020")
- * @param {string} [options.module] - Module format (default: "ESNext")
- * @param {boolean} [options.strict] - Enable strict type checking (default: true)
- * @param {boolean} [options.skipTypeCheck] - Skip type checking and only transform (default: false)
- * @param {string} [options.typeDefinitionPath] - Path to .d.ts file for type checking
- * @returns {Promise<{code: string, diagnostics: object[]}>} Transformed code and type diagnostics
- * @throws {SlothletError} If transformation fails
- * @public
- */
-export function transformTypeScriptStrict(filePath: string, options?: {
-    target?: string;
-    module?: string;
-    strict?: boolean;
-    skipTypeCheck?: boolean;
-    typeDefinitionPath?: string;
-}): Promise<{
-    code: string;
-    diagnostics: object[];
+export function createDataUrl(code: any): string;
+export function formatDiagnostics(diagnostics: any, ts: any): any;
+export function transformTypeScript(filePath: any, options?: {}): Promise<any>;
+export function transformTypeScriptStrict(filePath: any, options?: {}): Promise<{
+    code: any;
+    diagnostics: any[];
 }>;
-/**
- * Format TypeScript diagnostics into readable error messages
- * @param {object[]} diagnostics - TypeScript diagnostic objects
- * @param {object} ts - TypeScript module instance
- * @returns {string[]} Array of formatted error messages
- * @private
- */
-export function formatDiagnostics(diagnostics: object[], ts: object): string[];
 //# sourceMappingURL=typescript.d.mts.map

package/types/dist/lib/processors/typescript.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/typescript.mjs"],"names":[],"mappings":"AAqEA;;;;;;;;;;GAUG;AACH,8CATW,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;IACW,MAAM,GAAvB,MAAM;IACY,SAAS,GAA3B,OAAO;CACf,GAAU,OAAO,CAAC,MAAM,CAAC,CAiB3B;AAED;;;;;GAKG;AACH,oCAJW,MAAM,GACJ,MAAM,CAQlB;AAED;;;;;;;;;;;;GAYG;AACH,oDAXW,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;IACW,MAAM,GAAvB,MAAM;IACY,MAAM,GAAxB,OAAO;IACW,aAAa,GAA/B,OAAO;IACU,kBAAkB,GAAnC,MAAM;CACd,GAAU,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAC,CAAC,CA6F1D;AAED;;;;;;GAMG;AACH,+CALW,MAAM,EAAE,MACR,MAAM,GACJ,MAAM,EAAE,CAapB"}
+{"version":3,"file":"typescript.d.mts","sourceRoot":"","sources":["../../../../dist/lib/processors/typescript.mjs"],"names":[],"mappings":"AAA83B,iDAAoK;AAAm6D,kEAAkZ;AAArxF,+EAA4T;AAAoK;;;GAAm6D"}

package/types/dist/lib/runtime/runtime-asynclocalstorage.d.mts

@@ -1,72 +1,4 @@
-/**
- * Live binding to the current API (self-reference)
- * @type {Proxy}
- * @public
- *
- * @description
- * A proxy that provides access to the full API object within the current context.
- * Automatically resolves to the correct instance's API in AsyncLocalStorage context.
- *
- * @example
- * import { self } from "@cldmv/slothlet/runtime/async";
- *
- * export function callOtherFunction() {
- *   // Call another function in the same API
- *   return self.otherFunction();
- * }
- */
-export const self: ProxyConstructor;
-/**
- * User-provided context object
- * @type {Proxy}
- * @public
- *
- * @description
- * A proxy that provides access to user-provided context data (e.g., request data, user info).
- * Can be set via `slothlet.run()` or `slothlet.scope()`.
- *
- * @example
- * import { context } from "@cldmv/slothlet/runtime/async";
- *
- * export function getUserInfo() {
- *   // Access user-provided context
- *   return {
- *     userId: context.userId,
- *     userName: context.userName
- *   };
- * }
- */
-export const context: ProxyConstructor;
-/**
- * Reference to initialization reference object
- * @type {Proxy}
- * @public
- *
- * @description
- * The reference object is merged directly into the API at initialization using the add API system.
- * It is NOT available as a runtime export. Access it directly from the API or via api.slothlet.diag.reference().
- *
- * @example
- * // Reference merged into API - access directly:
- * export function useReferenceData() {
- *   return self.myData; // if reference had myData property
- * }
- */
-/**
- * Current instance ID
- * @type {Proxy}
- * @public
- *
- * @description
- * A proxy that provides access to the current slothlet instance ID.
- * Useful for debugging and tracking which instance is handling a request.
- *
- * @example
- * import { instanceID } from "@cldmv/slothlet/runtime/async";
- *
- * export function getInstanceInfo() {
- *   return { instanceID };
- * }
- */
-export const instanceID: ProxyConstructor;
+export const context: {};
+export const instanceID: {};
+export const self: {};
 //# sourceMappingURL=runtime-asynclocalstorage.d.mts.map

package/types/dist/lib/runtime/runtime-asynclocalstorage.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-asynclocalstorage.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-asynclocalstorage.mjs"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;GAgBG;AACH,oCAgCE;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uCAkCE;AAEF;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,0CAqBE"}
+{"version":3,"file":"runtime-asynclocalstorage.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-asynclocalstorage.mjs"],"names":[],"mappings":"AAA2xB,yBAAmrB;AAAA,4BAA6V;AAA3mD,sBAA2lB"}

package/types/dist/lib/runtime/runtime-livebindings.d.mts

@@ -1,38 +1,3 @@
-/**
- * Live binding to the current API (self-reference)
- * @type {Proxy}
- * @public
- *
- * @description
- * A proxy that provides direct access to the current instance's API.
- * In live mode, this directly references the active instance without AsyncLocalStorage.
- *
- * @example
- * import { self } from "@cldmv/slothlet/runtime/live";
- *
- * export function callOtherFunction() {
- *   return self.otherFunction();
- * }
- */
-export const self: ProxyConstructor;
-/**
- * User-provided context object
- * @type {Proxy}
- * @public
- *
- * @description
- * A proxy that provides access to user-provided context data.
- * In live mode, this directly accesses the current instance's context.
- *
- * @example
- * import { context } from "@cldmv/slothlet/runtime/live";
- *
- * export function getUserInfo() {
- *   return {
- *     userId: context.userId,
- *     userName: context.userName
- *   };
- * }
- */
-export const context: ProxyConstructor;
+export const context: {};
+export const self: {};
 //# sourceMappingURL=runtime-livebindings.d.mts.map

package/types/dist/lib/runtime/runtime-livebindings.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-livebindings.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-livebindings.mjs"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;GAeG;AACH,oCAgCE;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,uCAkCE"}
+{"version":3,"file":"runtime-livebindings.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-livebindings.mjs"],"names":[],"mappings":"AAAwuB,yBAA2tB;AAAt1C,sBAA2nB"}

package/types/dist/lib/runtime/runtime.d.mts

@@ -1,40 +1,4 @@
-/**
- * Live binding to the current API instance. Resolves to the running Slothlet proxy,
- * giving API modules access to all other API methods without import cycles.
- *
- * @memberof module:@cldmv/slothlet/runtime
- * @type {object}
- * @example
- * import { self } from "@cldmv/slothlet/runtime";
- * // Inside an API function:
- * const result = await self.math.add(1, 2);
- */
-export const self: object;
-/**
- * The current ambient context object. Seeded at instance startup via `config.context` and
- * persists for the lifetime of the instance. `api.slothlet.context.run()` and `.scope()` can
- * temporarily override it for the duration of a single call, after which the previous context
- * is restored. Readable and writable.
- *
- * @memberof module:@cldmv/slothlet/runtime
- * @type {object}
- * @example
- * import { context } from "@cldmv/slothlet/runtime";
- * // Read the ambient context set via config.context or written by a previous call:
- * const userId = context.userId;
- * // context.run() overrides it only for the duration of that one call:
- * await api.slothlet.context.run({ userId: 42 }, myFn);
- */
-export const context: object;
-/**
- * Current Slothlet instance identifier. Unique per `slothlet()` call; useful when
- * multiple Slothlet instances coexist and you need to identify which one is active.
- *
- * @memberof module:@cldmv/slothlet/runtime
- * @type {string}
- * @example
- * import { instanceID } from "@cldmv/slothlet/runtime";
- * console.log(instanceID); // e.g. "slothlet-1"
- */
-export const instanceID: string;
+export const context: {};
+export const instanceID: {};
+export const self: {};
 //# sourceMappingURL=runtime.d.mts.map

package/types/dist/lib/runtime/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AAkEA;;;;;;;;;;GAUG;AACH,mBANU,MAAM,CAgCd;AAEF;;;;;;;;;;;;;;GAcG;AACH,sBARU,MAAM,CAiCd;AAEF;;;;;;;;;GASG;AACH,yBALU,MAAM,CAiBd"}
+{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AAA02B,yBAA4e;AAAA,4BAAoP;AAA7pC,sBAA6b"}