@cldmv/slothlet 3.3.0 → 3.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cldmv/slothlet",
-	"version": "3.3.0",
+	"version": "3.3.2",
 	"moduleVersions": {
 		"lazy": "3.0.0",
 		"eager": "3.0.0",
@@ -140,16 +140,18 @@
 		"lint": "eslint --config .configs/eslint.config.mjs .",
 		"inspect": "node tools/dev/inspect-api-structure.mjs",
 		"check:node-versions": "node tools/dev/check-node-versions.mjs",
+		"check:engines": "node tools/dev/check-engines.mjs",
 		"analyze": "node tools/dev/analyze-errors.mjs",
 		"fix:headers": "node tools/dev/fix-headers.mjs",
 		"build": "npm run build:dev",
-		"build:ci": "npm run build:cleanup && npm run build:dist && npm run build:types && npm run build:exports && npm run test:types && npm run build:prepend-license && npm run ci:cleanup-src",
-		"build:dev": "npm run build:cleanup && npm run build:dist && npm run build:types && npm run build:exports && npm run test:types && npm run build:prepend-license",
-		"build:dev:test": "npm run build:cleanup && npm run build:dist && npm run build:types && npm run build:exports && npm run test:types && npm run build:prepend-license && npm run build:cleanup",
-		"build:unsafe": "npm run build:cleanup && npm run build:dist && npm run build:types && npm run build:exports && npm run test:types && npm run build:prepend-license",
+		"build:ci": "npm run build:cleanup && npm run build:dist && npm run build:minify && npm run build:types && npm run build:exports && npm run test:types && npm run build:prepend-license && npm run ci:cleanup-src",
+		"build:dev": "npm run build:cleanup && npm run build:dist && npm run build:minify && npm run build:types && npm run build:exports && npm run test:types && npm run build:prepend-license",
+		"build:dev:test": "npm run build:cleanup && npm run build:dist && npm run build:minify && npm run build:types && npm run build:exports && npm run test:types && npm run build:prepend-license && npm run build:cleanup",
+		"build:unsafe": "npm run build:cleanup && npm run build:dist && npm run build:minify && npm run build:types && npm run build:exports && npm run test:types && npm run build:prepend-license",
 		"ci:cleanup-src": "node tools/ci/ci-cleanup-src.mjs",
 		"build:cleanup": "shx rm -rf types && shx rm -rf dist",
 		"build:dist": "shx mkdir -p dist && node tools/build/build-dist.mjs && shx rm -rf dist/**/*.backup",
+		"build:minify": "node tools/build/minify-dist.mjs",
 		"build:types": "npx tsc -p .configs/tsconfig.dts.jsonc",
 		"build:exports": "node tools/build/build-exports.mjs",
 		"build:prepend-license": "node tools/build/prepend-license.mjs dist",
@@ -228,7 +230,7 @@
 		"zero-dependencies"
 	],
 	"engines": {
-		"node": ">=16.20.2"
+		"node": ">=20.19.0"
 	},
 	"author": {
 		"name": "Shinrai",
@@ -249,8 +251,8 @@
 	},
 	"type": "module",
 	"peerDependencies": {
-		"esbuild": "^0.27.3",
-		"typescript": "^5.9.3"
+		"esbuild": "^0.28.0",
+		"typescript": "^6.0.3"
 	},
 	"peerDependenciesMeta": {
 		"esbuild": {
@@ -261,36 +263,39 @@
 		}
 	},
 	"devDependencies": {
-		"@cldmv/fix-headers": "^1.2.0",
-		"@cldmv/vitest-runner": "^1.0.3",
-		"@eslint/css": "^0.10.0",
-		"@eslint/js": "^9.33.0",
-		"@eslint/json": "^0.13.1",
-		"@eslint/markdown": "^7.2.0",
-		"@html-eslint/parser": "^0.45.0",
-		"@types/node": "^24.9.1",
-		"@vitest/coverage-v8": "^4.0.18",
+		"@cldmv/fix-headers": "^1.2.2",
+		"@cldmv/vitest-runner": "^1.1.0",
+		"@eslint/css": "^1.1.0",
+		"@eslint/js": "^10.0.1",
+		"@eslint/json": "^1.2.0",
+		"@eslint/markdown": "^8.0.1",
+		"@html-eslint/parser": "^0.59.0",
+		"@types/node": "^25.6.0",
+		"@vitest/coverage-v8": "^4.1.5",
 		"acorn": "^8.16.0",
-		"chalk": "^5.6.0",
+		"chalk": "^5.6.2",
 		"chokidar": "^5.0.0",
 		"dmd": "^7.1.1",
-		"esbuild": "^0.27.3",
-		"eslint": "^10.0.2",
+		"esbuild": "^0.28.0",
+		"eslint": "^10.2.1",
 		"estree-walker": "^3.0.3",
-		"globals": "^17.4.0",
-		"jsdoc": "^4.0.4",
-		"jsdoc-to-markdown": "^9.1.2",
+		"globals": "^17.5.0",
+		"jsdoc": "^4.0.5",
+		"jsdoc-to-markdown": "^9.1.3",
 		"jsdoc2md": "^1.0.0",
 		"jsonc-parser": "^3.3.1",
-		"prettier": "^3.3.3",
+		"prettier": "^3.8.3",
 		"shx": "^0.4.0",
-		"typescript": "^5.9.3",
-		"vest": "^5.4.6",
-		"vitest": "^4.0.18"
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.5"
+	},
+	"optionalDependencies": {
+		"@rolldown/binding-linux-x64-gnu": "1.0.0-rc.17"
 	},
 	"overrides": {
 		"minimatch": "^10.2.3",
-		"rollup": "^4.59.0"
+		"rollup": "^4.59.0",
+		"rolldown": "1.0.0-rc.17"
 	},
 	"repository": {
 		"type": "git",
@@ -308,10 +313,8 @@
 		"index.mjs",
 		"index.cjs",
 		"README.md",
+		"REFERENCE.md",
 		"LICENSE",
-		"docs/API-RULES.md",
-		"docs/API-RULES-CONDITIONS.md",
-		"AGENT-USAGE.md",
 		"types/dist/",
 		"types/index.d.mts",
 		"types/index.d.mts.map",

package/types/dist/lib/builders/api-assignment.d.mts

@@ -1,97 +1,8 @@
-/**
- * Manages unified API assignment logic
- * @class ApiAssignment
- * @extends ComponentBase
- * @package
- *
- * @description
- * Class-based utility for assigning values to API paths with collision detection,
- * wrapper sync, and merge operations. Extends ComponentBase for Slothlet property access.
- *
- * @example
- * const assignment = new ApiAssignment(slothlet);
- * assignment.assignToApiPath(api, "math", mathWrapper, {});
- */
 export class ApiAssignment extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Check if a value is a UnifiedWrapper proxy
-     * @param {unknown} value - Value to check
-     * @returns {boolean} True if value is a wrapper proxy
-     * @private
-     */
-    private isWrapperProxy;
-    /**
-     * Assign a value to an API object at a given property key.
-     * Handles wrapper sync, collision detection, and proper proxy preservation.
-     *
-     * @param {Object} targetApi - Target object to assign to (may be a UnifiedWrapper proxy)
-     * @param {string|symbol} key - Property name to assign
-     * @param {unknown} value - Value to assign (may be UnifiedWrapper proxy, raw value, etc.)
-     * @param {Object} options - Assignment options
-     * @param {boolean} [options.allowOverwrite=false] - Allow overwriting existing non-wrapper values
-     * @param {boolean} [options.mutateExisting=false] - Sync existing wrappers instead of replacing
-     * @param {boolean} [options.useCollisionDetection=false] - Enable collision detection using config.collision mode
-     * @param {Object} [options.config] - Slothlet config (uses config.collision.initial or config.collision.api)
-     * @param {string} [options.collisionContext="initial"] - Collision context: "initial" or "api"
-     * @param {Function} [options.syncWrapper] - Function to sync two wrapper proxies
-     * @returns {boolean} True if assignment succeeded, false if blocked by collision or other constraint
-     *
-     * @description
-     * This function encapsulates all assignment patterns from processFiles:
-     * - Direct assignment when no collision
-     * - Wrapper sync when both existing and new are wrappers
-     * - Collision detection using config.collision[context] mode (merge/replace/error/skip/warn)
-     * - Proper handling of UnifiedWrapper proxies (preserves them, doesn't unwrap)
-     *
-     * @example
-     * // Direct assignment
-     * assignment.assignToApiPath(api, "math", mathWrapper, {});
-     *
-     * @example
-     * // Sync existing wrapper with new data
-     * assignment.assignToApiPath(api, "config", newConfigWrapper, { mutateExisting: true, syncWrapper });
-     *
-     * @example
-     * // With collision detection
-     * assignment.assignToApiPath(api.math, "add", addFunction, {
-     *     useCollisionDetection: true,
-     *     config,
-     *     collisionContext: "initial"
-     * });
-     */
-    assignToApiPath(targetApi: any, key: string | symbol, value: unknown, options?: {
-        allowOverwrite?: boolean;
-        mutateExisting?: boolean;
-        useCollisionDetection?: boolean;
-        config?: any;
-        collisionContext?: string;
-        syncWrapper?: Function;
-    }): boolean;
-    /**
-     * Recursively merge a source object into a target object using assignToApiPath logic.
-     *
-     * @param {Object} targetApi - Target object
-     * @param {Object} sourceApi - Source object to merge from
-     * @param {Object} options - Assignment options (passed to assignToApiPath)
-     * @param {boolean} [options.removeMissing=false] - Remove keys from target that don't exist in source
-     * @returns {Promise<void>}
-     *
-     * @description
-     * Recursively walks the source object and assigns each value to the target using
-     * assignToApiPath. This provides consistent merge behavior for both initial build
-     * and hot reload operations.
-     *
-     * @example
-     * await assignment.mergeApiObjects(api.config, newConfigApi, {
-     *     mutateExisting: true,
-     *     syncWrapper,
-     *     removeMissing: false
-     * });
-     */
-    mergeApiObjects(targetApi: any, sourceApi: any, options?: {
-        removeMissing?: boolean;
-    }): Promise<void>;
+    isWrapperProxy(value: any): boolean;
+    assignToApiPath(targetApi: any, key: any, value: any, options?: {}): boolean;
+    mergeApiObjects(targetApi: any, sourceApi: any, options?: {}): Promise<void>;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=api-assignment.d.mts.map

package/types/dist/lib/builders/api-assignment.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"api-assignment.d.mts","sourceRoot":"","sources":["../../../../dist/lib/builders/api-assignment.mjs"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;GAaG;AACH;IACC,gCAA0C;IAc1C;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,qCAlCW,MAAM,GAAC,MAAM,SACb,OAAO,YAEf;QAA0B,cAAc,GAAhC,OAAO;QACW,cAAc,GAAhC,OAAO;QACW,qBAAqB,GAAvC,OAAO;QACU,MAAM;QACN,gBAAgB,GAAjC,MAAM;QACa,WAAW;KACtC,GAAU,OAAO,CA+fnB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,0DAfG;QAA0B,aAAa,GAA/B,OAAO;KACf,GAAU,OAAO,CAAC,IAAI,CAAC,CA2FzB;CACD;8BA5pB6B,0CAA0C"}
+{"version":3,"file":"api-assignment.d.mts","sourceRoot":"","sources":["../../../../dist/lib/builders/api-assignment.mjs"],"names":[],"mappings":"AAAyI;IAA0C,gCAAwC;IAAsC,oCAA6D;IAAA,6EAA+nV;IAAA,6EAA6iD;CAAC;8BAAl9Y,0CAA0C"}

package/types/dist/lib/builders/api_builder.d.mts

@@ -1,96 +1,107 @@
-/**
- * Builds final API with built-in methods attached
- * @class ApiBuilder
- * @extends ComponentBase
- * @package
- *
- * @description
- * Class-based builder for final API construction with built-in namespace attachment.
- * Extends ComponentBase for common Slothlet property access.
- *
- * @example
- * const builder = new ApiBuilder(slothlet);
- * const api = await builder.buildFinalAPI(userApi);
- */
 export class ApiBuilder extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Build final API with built-in methods attached
-     * @param {Object} userApi - User API object from mode builder
-     * @returns {Promise<Object>} Final API with built-ins attached
-     * @public
-     */
-    public buildFinalAPI(userApi: any): Promise<any>;
-    /**
-     * @param {object} userApi - User API object (for diagnostics).
-     * @returns {Promise<object>} Slothlet namespace object.
-     * @private
-     *
-     * @description
-     * Builds the slothlet namespace with version metadata, API controls, and lifecycle
-     * helpers for the current instance.
-     *
-     * @example
-     * const namespace = await this.createSlothletNamespace(api);
-     */
-    private createSlothletNamespace;
-    /**
-     * Create root-level shutdown function (convenience)
-     * @returns {Function} Shutdown function that dynamically calls user hooks
-     * @private
-     */
-    private createShutdownFunction;
-    /**
-     * Create root-level run function (per-request context isolation)
-     * @returns {Function} Run function that executes callbacks with isolated context
-     * @private
-     */
-    private createRunFunction;
-    /**
-     * Create root-level scope function (structured per-request context with options)
-     * @returns {Function} Scope function that executes functions with isolated context
-     * @private
-     */
-    private createScopeFunction;
-    /**
-     * Create root-level destroy function (permanent destruction)
-     * @param {Object} api - Full API object
-     * @returns {Function} Destroy function that dynamically calls user hooks
-     * @private
-     */
-    private createDestroyFunction;
-    /**
-     * Attach built-in methods to user API
-     * @param {Object} userApi - User API object
-     * @param {Object} builtins - Built-in methods to attach
-     * @private
-     */
-    private attachBuiltins;
+    buildFinalAPI(userApi: any): Promise<any>;
+    createSlothletNamespace(userApi: any): Promise<{
+        i18n: {
+            setLanguage: typeof setLanguage;
+            getLanguage: typeof getLanguage;
+            translate: typeof translate;
+            t: typeof translate;
+            initI18n: typeof initI18n;
+        };
+        version: string;
+        instanceID: any;
+        types: {
+            UNMATERIALIZED: symbol;
+            IN_FLIGHT: symbol;
+        };
+        api: {
+            add: (apiPath: any, folderPath: any, options?: {}, versionConfig?: null) => Promise<any>;
+            remove: (pathOrModuleId: any) => Promise<any>;
+            reload: (pathOrModuleId: any, options: any) => Promise<any>;
+        };
+        sanitize: (str: any) => any;
+        context: {
+            get: (key: any) => any;
+            diagnostics: () => {
+                instanceID: any;
+                managerType: any;
+                instancesMapSize: any;
+                instancesMapKeys: any[];
+                baseContext: any;
+            } | undefined;
+            run: (contextData: any, callback: any, ...args: any[]) => Promise<any>;
+            scope: (options: any) => Promise<any>;
+        };
+        hook: {
+            on: (typePattern: any, handler: any, options?: {}) => any;
+            remove: (filter?: {}) => any;
+            clear: (filter?: {}) => any;
+            off: (idOrFilter: any) => any;
+            enable: (filter?: {}) => any;
+            disable: (filter?: {}) => any;
+            list: (filter?: {}) => any;
+        };
+        metadata: {
+            setGlobal: (key: any, value: any) => any;
+            set: (fn: any, key: any, value: any) => any;
+            remove: (fn: any, key: any) => any;
+            setFor: (pathOrModuleId: any, keyOrObj: any, value: any) => any;
+            removeFor: (pathOrModuleId: any, key: any) => any;
+            setForVersion: (logicalPath: any, versionTag: any, keyOrObj: any, value: any) => any;
+            getForVersion: (logicalPath: any, versionTag: any) => any;
+        };
+        scope: (options: any) => Promise<any>;
+        run: (contextData: any, callback: any, ...args: any[]) => Promise<any>;
+        reload: (options?: {}) => Promise<any>;
+        shutdown: () => Promise<any>;
+        owner: {
+            get: (apiPath: any) => any;
+        };
+        materialize: Readonly<{
+            readonly materialized: any;
+            get: any;
+            wait: any;
+        }>;
+        lifecycle: {
+            on: any;
+            off: any;
+        };
+        env: any;
+        versioning: {
+            list: (logicalPath: any) => any;
+            setDefault: (logicalPath: any, versionTag: any) => any;
+            unregister: (logicalPath: any, versionTag: any) => Promise<boolean>;
+            getVersionMetadata: (logicalPath: any, versionTag: any) => any;
+            setVersionMetadata: (logicalPath: any, versionTag: any, patch: any) => any;
+        };
+        permissions: {
+            addRule: (rule: any) => any;
+            removeRule: (ruleId: any) => any;
+            self: {
+                access: (target: any) => any;
+                rules: () => any;
+            };
+            global: {
+                checkAccess: (caller: any, target: any) => any;
+                rulesForPath: (path: any) => any;
+                rulesByModule: (moduleID: any) => any;
+            };
+            control: {
+                enable: () => void;
+                disable: () => void;
+            };
+        };
+    }>;
+    createShutdownFunction(): () => Promise<any>;
+    createRunFunction(): (contextData: any, callback: any, ...args: any[]) => Promise<any>;
+    createScopeFunction(): (options: any) => Promise<any>;
+    createDestroyFunction(api: any): () => Promise<void>;
+    attachBuiltins(userApi: any, builtins: any): void;
 }
-/**
- * i18n translation helpers exposed on every Slothlet namespace.
- */
-export type I18nNamespace = {
-    /**
-     * - Set the active locale (e.g. "en-us").
-     */
-    setLanguage: Function;
-    /**
-     * - Return the current active locale string.
-     */
-    getLanguage: Function;
-    /**
-     * - Translate an error code with optional params.
-     */
-    translate: Function;
-    /**
-     * - Alias for translate.
-     */
-    t: Function;
-    /**
-     * - Initialise the i18n system with options.
-     */
-    initI18n: Function;
-};
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+import { setLanguage } from "@cldmv/slothlet/i18n";
+import { getLanguage } from "@cldmv/slothlet/i18n";
+import { translate } from "@cldmv/slothlet/i18n";
+import { initI18n } from "@cldmv/slothlet/i18n";
 //# sourceMappingURL=api_builder.d.mts.map

package/types/dist/lib/builders/api_builder.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"api_builder.d.mts","sourceRoot":"","sources":["../../../../dist/lib/builders/api_builder.mjs"],"names":[],"mappings":"AAyEA;;;;;;;;;;;;;GAaG;AACH;IACC,gCAAuC;IAcvC;;;;;OAKG;IACH,oCAHa,OAAO,KAAQ,CAiG3B;IAED;;;;;;;;;;;OAWG;IACH,gCA0iDC;IAED;;;;OAIG;IACH,+BAYC;IAED;;;;OAIG;IACH,0BAgCC;IAED;;;;OAIG;IACH,4BAoMC;IAED;;;;;OAKG;IACH,8BAyCC;IAED;;;;;OAKG;IACH,uBAgCC;CACD;;;;;;;;;;;;;;;;;;;;;;;;;;8BAtkE6B,0CAA0C"}
+{"version":3,"file":"api_builder.d.mts","sourceRoot":"","sources":["../../../../dist/lib/builders/api_builder.mjs"],"names":[],"mappings":"AAAghB;IAAuC,gCAAqC;IAAsC,0CAA66C;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAqyjB;IAAA,6CAAqR;IAAA,uFAA0vB;IAAA,sDAAw+I;IAAA,qDAAmkB;IAAA,kDAA2Z;CAAC;8BAAjx0B,0CAA0C;4BAA2H,sBAAsB;4BAAtB,sBAAsB;0BAAtB,sBAAsB;yBAAtB,sBAAsB"}

package/types/dist/lib/builders/builder.d.mts

@@ -1,60 +1,6 @@
-/**
- * API builder class for orchestrating mode-based API construction.
- * @class Builder
- * @extends ComponentBase
- * @package
- *
- * @description
- * Orchestrates API building by delegating to mode-specific builders (eager/lazy).
- * Extends ComponentBase for access to Slothlet configuration and error classes.
- *
- * @example
- * const builder = new Builder(slothlet);
- * const api = await builder.buildAPI({ dir: "./api" });
- */
 export class Builder extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Build API from directory or file.
-     * @param {Object} options - Build options
-     * @param {string} options.dir - Directory or file to build from
-     * @param {string} [options.mode="eager"] - Loading mode (eager or lazy)
-     * @param {Object} [options.ownership] - Ownership manager (uses slothlet's if not provided)
-     * @param {Object} [options.contextManager] - Context manager (uses slothlet's if not provided)
-     * @param {string} [options.instanceID] - Instance ID (uses slothlet's if not provided)
-     * @param {Object} [options.config] - Configuration (uses slothlet's if not provided)
-     * @param {string} [options.apiPathPrefix=""] - Prefix for API paths (for api.add support)
-     * @param {string} [options.collisionContext="initial"] - Collision context
-     * @param {Function|null} [options.fileFilter=null] - Optional filter function (fileName) => boolean to load specific files only
-     * @returns {Promise<Object>} Raw API object (unwrapped)
-     * @public
-     *
-     * @description
-     * Validates inputs and delegates to mode-specific builder (buildEagerAPI or buildLazyAPI).
-     * When fileFilter is provided, only files matching the filter are loaded.
-     *
-     * @example
-     * const api = await builder.buildAPI({ dir: "./api_tests/api_test", mode: "eager" });
-     *
-     * @example
-     * // Load specific file only
-     * const api = await builder.buildAPI({
-     *   dir: "./api_tests/api_test",
-     *   mode: "eager",
-     *   fileFilter: (fileName) => fileName === "math.mjs"
-     * });
-     */
-    public buildAPI(options: {
-        dir: string;
-        mode?: string;
-        ownership?: any;
-        contextManager?: any;
-        instanceID?: string;
-        config?: any;
-        apiPathPrefix?: string;
-        collisionContext?: string;
-        fileFilter?: Function | null;
-    }): Promise<any>;
+    buildAPI(options: any): Promise<any>;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=builder.d.mts.map

package/types/dist/lib/builders/builder.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.mts","sourceRoot":"","sources":["../../../../dist/lib/builders/builder.mjs"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;GAaG;AACH;IACC,gCAAoC;IAiBpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,yBA3BG;QAAwB,GAAG,EAAnB,MAAM;QACW,IAAI,GAArB,MAAM;QACW,SAAS;QACT,cAAc;QACd,UAAU,GAA3B,MAAM;QACW,MAAM;QACN,aAAa,GAA9B,MAAM;QACW,gBAAgB,GAAjC,MAAM;QACkB,UAAU,GAAlC,WAAS,IAAI;KACrB,GAAU,OAAO,KAAQ,CA+E3B;CACD;8BA9H6B,0CAA0C"}
+{"version":3,"file":"builder.d.mts","sourceRoot":"","sources":["../../../../dist/lib/builders/builder.mjs"],"names":[],"mappings":"AAAoE;IAAoC,gCAAkC;IAAsC,qCAAuxB;CAAC;8BAA/6B,0CAA0C"}

package/types/dist/lib/builders/modes-processor.d.mts

@@ -1,32 +1,8 @@
-/**
- * ModesProcessor - Handles mode-specific file and directory processing.
- *
- * @class
- * @extends ComponentBase
- * @package
- */
 export class ModesProcessor extends ComponentBase {
     static slothletProperty: string;
-    processFiles(api: any, files: any, directory: any, currentDepth: any, mode: any, isRoot: any, recursive: any, populateDirectly?: boolean, apiPathPrefix?: string, collisionContext?: string, moduleID?: any, sourceFolder?: any, cacheBust?: any, collisionModeOverride?: any): Promise<any>;
-    /**
-     * Create lazy wrapper for subdirectory (lazy mode only)
-     * @param {Object} dir - Directory structure
-     * @param {string} apiPath - Current API path
-     * @param {Object} config - Configuration
-     * @returns {Proxy} Lazy unified wrapper
-     * @public
-     */
-    public createLazySubdirectoryWrapper(dir: any, apiPath: string, moduleID?: any, sourceFolder?: any, cacheBust?: any, fileFolderCollisionImpl?: any, collisionMode?: string): ProxyConstructor;
-    /**
-     * Apply root contributor pattern - merge API into root function
-     * @param {Object} api - API object with properties
-     * @param {Function|null} rootFunction - Root contributor function
-     * @param {Object} config - Configuration
-     * @param {string} mode - Mode name for debug messages
-     * @returns {Promise<Object|Function>} Final API (function if root contributor, object otherwise)
-     * @public
-     */
-    public applyRootContributor(api: any, rootFunction: Function | null, mode: string): Promise<any | Function>;
+    processFiles(api: any, files: any, directory: any, currentDepth: any, mode: any, isRoot: any, recursive: any, populateDirectly?: boolean, apiPathPrefix?: string, collisionContext?: string, moduleID?: null, sourceFolder?: null, cacheBust?: null, collisionModeOverride?: null): Promise<any>;
+    createLazySubdirectoryWrapper(dir: any, apiPath: any, moduleID?: null, sourceFolder?: null, cacheBust?: null, fileFolderCollisionImpl?: null, collisionMode?: string): any;
+    applyRootContributor(api: any, rootFunction: any, mode: any): Promise<any>;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=modes-processor.d.mts.map

package/types/dist/lib/builders/modes-processor.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"modes-processor.d.mts","sourceRoot":"","sources":["../../../../dist/lib/builders/modes-processor.mjs"],"names":[],"mappings":"AA8BA;;;;;;GAMG;AACH;IACC,gCAA2C;IAS3C,6RA+3CC;IACD;;;;;;;OAOG;IACH,wDALW,MAAM,gIA6WhB;IACD;;;;;;;;OAQG;IACH,oDANW,WAAS,IAAI,QAEb,MAAM,GACJ,OAAO,CAAC,cAAe,CAAC,CAoBpC;CACD;8BAjyD6B,0CAA0C"}
+{"version":3,"file":"modes-processor.d.mts","sourceRoot":"","sources":["../../../../dist/lib/builders/modes-processor.mjs"],"names":[],"mappings":"AAAmQ;IAA2C,gCAAyC;IAAsC,iSAA665B;IAAA,2KAAq3M;IAAA,2EAAwS;CAAC;8BAA/6nC,0CAA0C"}