@soederpop/luca 0.0.28 → 0.0.30

package/src/introspection/index.ts

@@ -75,6 +75,11 @@ export type HelperIntrospection = {
 	envVars?: string[]
 	// class-level @example blocks from JSDoc
 	examples?: ExampleIntrospection[]
+	// referenced type definitions resolved from parameter and return types
+	types?: Record<string, {
+		description: string;
+		properties: Record<string, { type: string; description: string; optional?: boolean }>
+	}>
 }
 
 export type RegistryIntrospection = {
@@ -203,6 +208,7 @@ export function setBuildTimeData(key: string, data: HelperIntrospection) {
 		getters: data.getters || existing?.getters || {},
 		envVars: existing?.envVars || data.envVars || [],
 		examples: data.examples || existing?.examples,
+		types: { ...(existing?.types || {}), ...(data.types || {}) },
 	})
 }
 
@@ -259,6 +265,7 @@ export function interceptRegistration(registry: any, helperConstructor: any) {
 			? helperConstructor.envVars
 			: (existing?.envVars || []),
 		examples: existing?.examples,
+		types: existing?.types,
 	}
 
 	// Always populate state and options from Zod schemas at runtime

package/src/introspection/scan.ts

@@ -189,6 +189,7 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
     const getters = this.extractGetters(classNode, sourceFile);
     const events = this.extractEvents(classNode, sourceFile);
     const examples = this.extractJSDocExamples(classNode);
+    const types = this.collectReferencedTypes(methods, getters, sourceFile);
 
     // state and options are derived at runtime from Zod schemas
     // via interceptRegistration — no need to extract them at build time
@@ -204,6 +205,7 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
       options: {},
       envVars: [],
       ...(examples.length > 0 ? { examples } : {}),
+      ...(Object.keys(types).length > 0 ? { types } : {}),
     };
   }
 
@@ -230,7 +232,7 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
    * These are framework internals (class references, utility objects) not useful in inspection.
    */
   private static CONTAINER_SKIP_GETTERS = new Set([
-    'Feature', 'Helper', 'State', 'z', 'features',
+    'Feature', 'Helper', 'State', 'z',
   ]);
 
   private extendsContainer(classNode: ts.ClassDeclaration): boolean {
@@ -298,6 +300,9 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
         // Skip methods starting with _ (internal methods like _hide)
         if (methodName.startsWith('_')) continue;
 
+        // Skip methods tagged with @internal
+        if (this.hasJSDocTag(member, 'internal')) continue;
+
         const description = this.extractJSDocDescription(member) || '';
         const parameters = this.extractParameters(member);
         const required = this.extractRequiredParameters(member);
@@ -327,6 +332,9 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
         // Skip container framework getters
         if (IntrospectionScannerFeature.CONTAINER_SKIP_GETTERS.has(getterName)) continue;
 
+        // Skip getters tagged with @internal
+        if (this.hasJSDocTag(member, 'internal')) continue;
+
         // Skip private getters unless includePrivate is true
         const isPrivate = member.modifiers?.some(mod => mod.kind === ts.SyntaxKind.PrivateKeyword);
         if (isPrivate && !this.options.includePrivate) continue;
@@ -336,7 +344,7 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
         if (isStatic) continue;
 
         const description = this.extractJSDocDescriptionFromAccessor(member) || '';
-        const returns = member.type ? member.type.getText() : 'any';
+        const returns = this.resolveReturnType(member, member.type, 'any');
         const examples = this.extractJSDocExamples(member);
 
         getters[getterName] = {
@@ -486,6 +494,9 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
         const isStatic = member.modifiers?.some(mod => mod.kind === ts.SyntaxKind.StaticKeyword);
         if (isStatic) continue;
 
+        // Skip methods tagged with @internal
+        if (this.hasJSDocTag(member, 'internal')) continue;
+
         const description = this.extractJSDocDescription(member) || '';
         const parameters = this.extractParameters(member);
         const required = this.extractRequiredParameters(member);
@@ -539,8 +550,11 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
         const isStatic = member.modifiers?.some(mod => mod.kind === ts.SyntaxKind.StaticKeyword);
         if (isStatic) continue;
 
+        // Skip getters tagged with @internal
+        if (this.hasJSDocTag(member, 'internal')) continue;
+
         const description = this.extractJSDocDescriptionFromAccessor(member) || '';
-        const returns = member.type ? member.type.getText() : 'any';
+        const returns = this.resolveReturnType(member, member.type, 'any');
         const examples = this.extractJSDocExamples(member);
 
         getters[getterName] = {
@@ -554,6 +568,57 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
     return getters;
   }
 
+  /**
+   * Extract a return type from a node, preferring explicit TS annotation,
+   * falling back to JSDoc @returns {Type}, then to the given default.
+   */
+  private resolveReturnType(node: ts.Node, typeNode: ts.TypeNode | undefined, fallback: string): string {
+    if (typeNode) return typeNode.getText();
+
+    const sourceFile = node.getSourceFile();
+    const fullText = sourceFile.getFullText();
+    const ranges = ts.getLeadingCommentRanges(fullText, node.getFullStart());
+
+    if (ranges && ranges.length > 0) {
+      for (let i = ranges.length - 1; i >= 0; i--) {
+        const range = ranges[i];
+        if (!range) continue;
+        const commentText = fullText.substring(range.pos, range.end);
+        if (!commentText.startsWith('/**')) continue;
+
+        const match = commentText.match(/@returns?\s*\{([^}]+)\}/);
+        if (match) return match[1].trim();
+      }
+    }
+
+    return fallback;
+  }
+
+  /**
+   * Check if a node's JSDoc comment contains a specific @tag (e.g. @internal).
+   */
+  private hasJSDocTag(node: ts.Node, tagName: string): boolean {
+    const sourceFile = node.getSourceFile();
+    const fullText = sourceFile.getFullText();
+    const ranges = ts.getLeadingCommentRanges(fullText, node.getFullStart());
+
+    if (!ranges || ranges.length === 0) return false;
+
+    for (let i = ranges.length - 1; i >= 0; i--) {
+      const range = ranges[i];
+      if (!range) continue;
+      const commentText = fullText.substring(range.pos, range.end);
+      if (!commentText.startsWith('/**')) continue;
+
+      // Check for @tagName anywhere in the JSDoc
+      if (new RegExp(`@${tagName}\\b`).test(commentText)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
   private extractJSDocDescriptionFromAccessor(node: ts.GetAccessorDeclaration): string | null {
     const sourceFile = node.getSourceFile();
     const fullText = sourceFile.getFullText();
@@ -781,6 +846,161 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
     return Object.keys(members).length > 0 ? members : null as any;
   }
 
+  /**
+   * Collect all non-primitive type names referenced in method parameters and return types,
+   * then resolve each to its properties from the source file. Returns a map of type name
+   * to its property definitions, suitable for emitting as standalone interface declarations.
+   */
+  private collectReferencedTypes(
+    methods: Record<string, MethodIntrospection>,
+    getters: Record<string, { returns: string; description: string }>,
+    sourceFile: ts.SourceFile
+  ): Record<string, { description: string; properties: Record<string, { type: string; description: string; optional?: boolean }> }> {
+    const types: Record<string, { description: string; properties: Record<string, { type: string; description: string; optional?: boolean }> }> = {};
+    const seen = new Set<string>();
+
+    const tryResolve = (rawType: string) => {
+      // Extract type names from complex type strings
+      // e.g. "Promise<GrepMatch[]>" -> "GrepMatch"
+      // e.g. "GrepOptions" -> "GrepOptions"
+      // e.g. "string | Foo" -> "Foo"
+      // e.g. "Omit<GrepOptions, 'pattern'>" -> "GrepOptions"
+      const typeNames = this.extractTypeNames(rawType);
+
+      for (const typeName of typeNames) {
+        if (seen.has(typeName)) continue;
+        seen.add(typeName);
+
+        if (IntrospectionScannerFeature.PRIMITIVE_TYPES.has(typeName)) continue;
+
+        const properties = this.resolveTypePropertiesWithOptional(typeName, sourceFile);
+        if (properties && Object.keys(properties).length > 0) {
+          // Extract JSDoc description from the type declaration itself
+          const description = this.extractTypeDescription(typeName, sourceFile) || '';
+          types[typeName] = { description, properties };
+
+          // Recursively resolve types referenced in properties
+          for (const prop of Object.values(properties)) {
+            tryResolve(prop.type);
+          }
+        }
+      }
+    };
+
+    // Collect from method parameters and return types
+    for (const method of Object.values(methods)) {
+      for (const param of Object.values(method.parameters || {})) {
+        tryResolve(param.type);
+      }
+      if (method.returns) {
+        tryResolve(method.returns);
+      }
+    }
+
+    // Collect from getter return types
+    for (const getter of Object.values(getters)) {
+      if (getter.returns) {
+        tryResolve(getter.returns);
+      }
+    }
+
+    return types;
+  }
+
+  /**
+   * Extract concrete type names from a potentially complex type string.
+   * Handles generics, unions, intersections, arrays, and utility types.
+   */
+  private extractTypeNames(typeStr: string): string[] {
+    if (!typeStr) return [];
+
+    // Remove Promise<...> wrapper but keep the inner type
+    // Remove array suffix [], Partial<>, Omit<>, Pick<>, etc.
+    // Split on | and & for unions/intersections
+    const names: string[] = [];
+
+    // Match identifiers that look like type names (PascalCase or known patterns)
+    // This regex finds all capitalized identifiers that aren't JS built-ins
+    const matches = typeStr.match(/\b([A-Z][A-Za-z0-9_]*)\b/g) || [];
+    const BUILTIN_TYPES = new Set([
+      'Promise', 'Array', 'Record', 'Map', 'Set', 'WeakMap', 'WeakSet',
+      'Partial', 'Required', 'Readonly', 'Pick', 'Omit', 'Exclude', 'Extract',
+      'Buffer', 'Date', 'RegExp', 'Error', 'Function', 'Symbol',
+      'AsyncIterable', 'Iterable', 'Iterator', 'AsyncIterator',
+      'InstanceType', 'ReturnType', 'Parameters',
+      'HTMLElement', 'Event', 'EventTarget',
+      'Stats', // Node.js fs.Stats — commonly used but not resolvable in-file
+    ]);
+
+    for (const match of matches) {
+      if (!BUILTIN_TYPES.has(match) && !IntrospectionScannerFeature.PRIMITIVE_TYPES.has(match.toLowerCase())) {
+        names.push(match);
+      }
+    }
+
+    return [...new Set(names)];
+  }
+
+  /**
+   * Like resolveTypeProperties but also captures whether each property is optional (has ?).
+   */
+  private resolveTypePropertiesWithOptional(typeName: string, sourceFile: ts.SourceFile): Record<string, { type: string; description: string; optional?: boolean }> | null {
+    for (const statement of sourceFile.statements) {
+      if (ts.isTypeAliasDeclaration(statement) && statement.name.text === typeName) {
+        if (ts.isTypeLiteralNode(statement.type)) {
+          return this.extractTypeLiteralMembersWithOptional(statement.type, sourceFile);
+        }
+      }
+      if (ts.isInterfaceDeclaration(statement) && statement.name.text === typeName) {
+        return this.extractInterfaceMembersWithOptional(statement, sourceFile);
+      }
+    }
+    return null;
+  }
+
+  private extractTypeLiteralMembersWithOptional(node: ts.TypeLiteralNode, sourceFile: ts.SourceFile): Record<string, { type: string; description: string; optional?: boolean }> | null {
+    const members: Record<string, { type: string; description: string; optional?: boolean }> = {};
+    for (const member of node.members) {
+      if (ts.isPropertySignature(member) && member.name) {
+        const name = member.name.getText();
+        const type = member.type ? member.type.getText() : 'any';
+        const description = this.extractJSDocFromNode(member, sourceFile) || '';
+        const optional = !!member.questionToken;
+        members[name] = { type, description, ...(optional ? { optional } : {}) };
+      }
+    }
+    return Object.keys(members).length > 0 ? members : null;
+  }
+
+  private extractInterfaceMembersWithOptional(node: ts.InterfaceDeclaration, sourceFile: ts.SourceFile): Record<string, { type: string; description: string; optional?: boolean }> | null {
+    const members: Record<string, { type: string; description: string; optional?: boolean }> = {};
+    for (const member of node.members) {
+      if (ts.isPropertySignature(member) && member.name) {
+        const name = member.name.getText();
+        const type = member.type ? member.type.getText() : 'any';
+        const description = this.extractJSDocFromNode(member, sourceFile) || '';
+        const optional = !!member.questionToken;
+        members[name] = { type, description, ...(optional ? { optional } : {}) };
+      }
+    }
+    return Object.keys(members).length > 0 ? members : null;
+  }
+
+  /**
+   * Extract the JSDoc description from a type alias or interface declaration.
+   */
+  private extractTypeDescription(typeName: string, sourceFile: ts.SourceFile): string | null {
+    for (const statement of sourceFile.statements) {
+      if (
+        (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) &&
+        statement.name.text === typeName
+      ) {
+        return this.extractJSDocFromNode(statement, sourceFile);
+      }
+    }
+    return null;
+  }
+
   /**
    * Extracts a JSDoc description from any node that may have leading comments.
    */
@@ -828,10 +1048,7 @@ export class IntrospectionScannerFeature extends Feature<IntrospectionScannerSta
   }
 
   private extractReturnType(method: ts.MethodDeclaration): string {
-    if (method.type) {
-      return method.type.getText();
-    }
-    return 'void';
+    return this.resolveReturnType(method, method.type, 'void');
   }
 
   private extractEvents(classNode: ts.ClassDeclaration, sourceFile: ts.SourceFile): Record<string, EventIntrospection> {

package/src/node/container.ts

@@ -57,7 +57,6 @@ import "./features/google-sheets";
 import "./features/google-calendar";
 import "./features/google-docs";
 import "./features/google-mail";
-import "./features/window-manager";
 import "./features/nlp";
 import "./features/process-manager"
 import "./features/tts";
@@ -102,7 +101,6 @@ import type { GoogleSheets } from './features/google-sheets';
 import type { GoogleCalendar } from './features/google-calendar';
 import type { GoogleDocs } from './features/google-docs';
 import type { GoogleMail } from './features/google-mail';
-import type { WindowManager } from './features/window-manager';
 import type { NLP } from './features/nlp';
 import type { ProcessManager } from './features/process-manager'
 import type { TTS } from './features/tts';
@@ -142,7 +140,6 @@ export {
   type GoogleCalendar,
   type GoogleDocs,
   type GoogleMail,
-  type WindowManager,
   type NLP,
   type ProcessManager,
   type TTS,
@@ -208,7 +205,6 @@ export interface NodeFeatures extends AvailableFeatures {
   googleCalendar: typeof GoogleCalendar;
   googleDocs: typeof GoogleDocs;
   googleMail: typeof GoogleMail;
-  windowManager: typeof WindowManager;
   nlp: typeof NLP;
   processManager: typeof ProcessManager;
   tts: typeof TTS;
@@ -233,9 +229,35 @@ export interface NodeContainerState extends ContainerState {
 }
 */
 
+/**
+ * Server-side container for Node.js and Bun environments. Extends the base Container with
+ * file system access, process management, git integration, and other server-side capabilities.
+ *
+ * Auto-enables core features on construction: fs, proc, git, grep, os, networking, ui, vm, esbuild, helpers.
+ * Also attaches Client, Server, Command, Endpoint, and Selector helper types, providing
+ * `container.client()`, `container.server()`, `container.command()`, etc. factory methods.
+ *
+ * @example
+ * ```ts
+ * import container from '@soederpop/luca/node'
+ *
+ * // File operations
+ * const content = container.fs.readFile('README.md')
+ *
+ * // Path utilities (scoped to cwd)
+ * const full = container.paths.resolve('src/index.ts')
+ *
+ * // Create a REST client
+ * const api = container.client('rest', { baseURL: 'https://api.example.com' })
+ *
+ * // Start an Express server
+ * const app = container.server('express', { port: 3000 })
+ * await app.start()
+ * ```
+ */
 export class NodeContainer<
   Features extends NodeFeatures = NodeFeatures,
-  K extends ContainerState = ContainerState 
+  K extends ContainerState = ContainerState
 > extends Container<Features, K> {
   fs!: FS;
   git!: Git;
@@ -268,7 +290,6 @@ export class NodeContainer<
   googleCalendar?: GoogleCalendar;
   googleDocs?: GoogleDocs;
   googleMail?: GoogleMail;
-  windowManager?: WindowManager;
   nlp?: NLP;
   processManager?: ProcessManager;
   tts?: TTS;
@@ -318,7 +339,7 @@ export class NodeContainer<
   }
 
   /** Returns the parsed package.json manifest for the current working directory. */
-  get manifest() {
+  get manifest(): Record<string, any> {
     try {
       const packageJson = this.fs.findUp("packageon");
 
@@ -339,19 +360,19 @@ export class NodeContainer<
   }
 
   /** Returns the parsed command-line arguments (from minimist). */
-  get argv() {
+  get argv(): Record<string, any> & { _: string[] } {
     return this.options as any;
   }
 
   /** Returns URL utility functions for parsing URIs. */
-  get urlUtils() {
+  get urlUtils(): { parse: (uri: string) => url.URL | null } {
     return {
       parse: (uri: string) => url.parse(uri)
     }
   }
 
   /** Returns path utility functions scoped to the current working directory (join, resolve, relative, dirname, parse). */
-  get paths() {
+  get paths(): { dirname: (path: string) => string; join: (...paths: string[]) => string; resolve: (...paths: string[]) => string; relative: (...paths: string[]) => string; basename: typeof basename; parse: typeof parse } {
     const { cwd } = this;
     return {
       dirname(path: string) {

package/src/node/features/content-db.ts

@@ -118,15 +118,15 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
   }
 
   /** Whether the content database has been loaded. */
-  get isLoaded() {
-    return this.state.get('started')
+  get isLoaded(): boolean {
+    return !!this.state.get('started')
   }
 
   _collection?: Collection
   private _contentbaseSeeded = false
 
   /** Returns the lazily-initialized Collection instance for the configured rootPath. */
-  get collection() {
+  get collection(): Collection {
     if (this._collection) return this._collection
 
     const opts: any = { rootPath: this.options.rootPath }
@@ -172,7 +172,7 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
   }
 
   /** Returns the absolute resolved path to the collection root directory. */
-  get collectionPath() {
+  get collectionPath(): string {
     return this.container.paths.resolve(this.options.rootPath)
   }
 
@@ -429,7 +429,7 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
 	  return this.collection.generateModelSummary(options)
   }
   
-  get modelDefinitionTable() {
+  get modelDefinitionTable(): Record<string, { description: string; glob: string; routePatterns: string[] }> {
     return Object.fromEntries(this.collection.modelDefinitions.map(d => {
       
       const prefixPattern = this.container.paths.relative(this.collection.resolve(d.prefix))
@@ -442,7 +442,7 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
     }))
   }
   
-  get fileTree() {
+  get fileTree(): string {
     return this.collection.renderFileTree()
   }
 
@@ -579,7 +579,7 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
   /**
    * Get the current search index status.
    */
-  get searchIndexStatus() {
+  get searchIndexStatus(): { exists: boolean; documentCount: number; chunkCount: number; embeddingCount: number; lastIndexedAt: any; provider: any; model: any; dimensions: number; dbSizeBytes: number } {
     if (!this._semanticSearch?.state?.get('dbReady')) {
       if (!this._hasSearchIndex()) {
         return { exists: false, documentCount: 0, chunkCount: 0, embeddingCount: 0, lastIndexedAt: null, provider: null, model: null, dimensions: 0, dbSizeBytes: 0 }

package/src/node/features/disk-cache.ts

@@ -37,7 +37,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
   static { Feature.register(this, 'diskCache') }
 
   /** Returns the underlying cacache instance configured with the cache directory path. */
-  get cache() {
+  get cache(): ReturnType<typeof this.create> {
     if(this._cache) { 
 	    return this._cache
     }
@@ -61,7 +61,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * await diskCache.saveFile('encodedImage', './images/photo.jpg', true)
    * ```
    */
-  async saveFile(key: string, outputPath: string, isBase64 = false) {
+  async saveFile(key: string, outputPath: string, isBase64 = false): Promise<Buffer | string> {
     const outPath = this.container.paths.resolve(outputPath)
     const content = await this.get(key)  
     const data = isBase64 ? Buffer.from(content, 'base64') : content 
@@ -79,7 +79,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * await diskCache.ensure('config', JSON.stringify(defaultConfig))
    * ```
    */
-  async ensure(key: string, content: string) {
+  async ensure(key: string, content: string): Promise<string> {
     const exists = await this.has(key)
     
     if (!exists) {
@@ -102,7 +102,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * await diskCache.copy('file1', 'file2', true) // force overwrite
    * ```
    */
-  async copy(source: string, destination: string, overwrite: boolean = false) {
+  async copy(source: string, destination: string, overwrite: boolean = false): Promise<string> {
     if(!overwrite && (await this.has(destination))) {
       throw new Error('Destination already exists')
     }
@@ -125,7 +125,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * await diskCache.move('old_key', 'new_key', true) // force overwrite
    * ```
    */
-  async move(source: string, destination: string, overwrite: boolean = false) {
+  async move(source: string, destination: string, overwrite: boolean = false): Promise<string> {
     if(!overwrite && (await this.has(destination))) {
       throw new Error('Destination already exists')
     }
@@ -147,7 +147,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * }
    * ```
    */
-  async has(key: string) {
+  async has(key: string): Promise<boolean> {
     return this.cache.get.info(key).then((r:any) => r != null)
   }
 
@@ -162,7 +162,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * const data = await diskCache.get('myData', true) // parse as JSON
    * ```
    */
-  async get(key: string, json = false) {
+  async get(key: string, json = false): Promise<any> {
     const val = this.options.encrypt 
       ? await this.securely.get(key) 
       : await this.cache.get(key).then((data: any) => data.data.toString())
@@ -191,7 +191,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * await diskCache.set('file', content, { size: 1024, type: 'image' })
    * ```
    */
-  async set(key: string, value: any, meta?: any) {
+  async set(key: string, value: any, meta?: any): Promise<any> {
     if (this.options.encrypt) {
       return this.securely.set(key, value, meta)
     }
@@ -216,7 +216,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * await diskCache.rm('obsoleteKey')
    * ```
    */
-  async rm(key: string) {
+  async rm(key: string): Promise<any> {
     return this.cache.rm.entry(key)
   }
   
@@ -230,7 +230,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * await diskCache.clearAll(true) // Must explicitly confirm
    * ```
    */
-  async clearAll(confirm = false) {
+  async clearAll(confirm = false): Promise<this> {
     if(confirm !== true) {
       throw new Error('Must confirm with clearAll(true)')
     }
@@ -281,7 +281,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * const decrypted = await cache.securely.get('sensitive')
    * ```
    */
-  get securely() {
+  get securely(): { set(name: string, payload: any, meta?: any): Promise<any>; get(name: string): Promise<any> } {
     const { secret, encrypt } = this.options
     
     if (!encrypt) {

package/src/node/features/esbuild.ts

@@ -27,7 +27,7 @@ export class ESBuild extends Feature {
    * @param options - The options to pass to esbuild
    * @returns The transformed code
    */
-  transformSync(code: string, options?: esbuild.TransformOptions) {
+  transformSync(code: string, options?: esbuild.TransformOptions): esbuild.TransformResult {
     return esbuild.transformSync(code, {
       loader: 'ts',
       format: 'esm',
@@ -44,7 +44,7 @@ export class ESBuild extends Feature {
    * @param options - The options to pass to esbuild
    * @returns The transformed code
    */
-  async transform(code: string, options?: esbuild.TransformOptions) {
+  async transform(code: string, options?: esbuild.TransformOptions): Promise<esbuild.TransformResult> {
     return esbuild.transform(code, {
       loader: 'ts',
       format: 'esm',
@@ -63,7 +63,7 @@ export class ESBuild extends Feature {
    * @param options - esbuild BuildOptions overrides
    * @returns The build result with outputFiles when write is false
    */
-  async bundle(entryPoints: string[], options?: esbuild.BuildOptions) {
+  async bundle(entryPoints: string[], options?: esbuild.BuildOptions): Promise<esbuild.BuildResult> {
     return esbuild.build({
       entryPoints,
       bundle: true,