isomorphic-jj 1.4.2 → 1.7.0

package/src/core/storage-manager.js

@@ -1,6 +1,6 @@
 /**
  * Storage Manager for isomorphic-jj
- * 
+ *
  * Manages JSON storage in .jj directory with atomic writes and caching.
  */
 
@@ -8,15 +8,15 @@ import { JJError } from '../utils/errors.js';
 
 export class Storage {
   /**
-   * @param {Object} fs - Filesystem implementation (Node fs, LightningFS, etc.)
+   * @param {any} fs - Filesystem implementation (Node fs, LightningFS, etc.)
    * @param {string} dir - Repository directory path
    */
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
     this.jjDir = `${dir}/.jj`;
-    this.repoDir = `${dir}/.jj/repo`;  // Core repo data
-    this.workingCopyDir = `${dir}/.jj/working_copy`;  // Default workspace working copy
+    this.repoDir = `${dir}/.jj/repo`; // Core repo data
+    this.workingCopyDir = `${dir}/.jj/working_copy`; // Default workspace working copy
     this.cache = new Map();
   }
 
@@ -44,16 +44,20 @@ export class Storage {
       // Create default workspace directory
       await this.fs.promises.mkdir(`${this.workingCopyDir}/default`, { recursive: true });
     } catch (error) {
-      throw new JJError('STORAGE_INIT_FAILED', `Failed to initialize .jj directory: ${error.message}`, {
-        dir: this.jjDir,
-        originalError: error,
-      });
+      throw new JJError(
+        'STORAGE_INIT_FAILED',
+        `Failed to initialize .jj directory: ${error.message}`,
+        {
+          dir: this.jjDir,
+          originalError: error,
+        }
+      );
     }
   }
 
   /**
    * Read and parse JSON file
-   * 
+   *
    * @param {string} path - Relative path from .jj directory
    * @returns {Promise<Object|null>} Parsed JSON or null if file doesn't exist
    */
@@ -83,7 +87,7 @@ export class Storage {
 
   /**
    * Write JSON file atomically
-   * 
+   *
    * @param {string} path - Relative path from .jj directory
    * @param {Object|string} data - Data to write (object will be stringified)
    */
@@ -111,7 +115,9 @@ export class Storage {
       // Clean up temp file
       try {
         await this.fs.promises.unlink(tmpPath);
-      } catch {}
+      } catch {
+        // Best-effort cleanup; ignore if the temp file is already gone.
+      }
 
       throw new JJError('STORAGE_WRITE_FAILED', `Failed to write ${path}: ${error.message}`, {
         path: fullPath,
@@ -122,9 +128,9 @@ export class Storage {
 
   /**
    * Read JSONL file (newline-delimited JSON)
-   * 
+   *
    * @param {string} path - Relative path from .jj directory
-   * @returns {Promise<Array>} Array of parsed JSON objects
+   * @returns {Promise<Array<any>>} Array of parsed JSON objects
    */
   async readLines(path) {
     const fullPath = `${this.jjDir}/${path}`;
@@ -134,8 +140,8 @@ export class Storage {
       return content
         .trim()
         .split('\n')
-        .filter((line) => line.length > 0)
-        .map((line) => JSON.parse(line));
+        .filter((/** @type {any} */ line) => line.length > 0)
+        .map((/** @type {any} */ line) => JSON.parse(line));
     } catch (error) {
       if (error.code === 'ENOENT') {
         return [];
@@ -149,7 +155,7 @@ export class Storage {
 
   /**
    * Append line to JSONL file
-   * 
+   *
    * @param {string} path - Relative path from .jj directory
    * @param {string} line - JSON string to append
    */
@@ -177,13 +183,13 @@ export class Storage {
 
   /**
    * Check if file exists
-   * 
+   *
    * @param {string} path - Relative path from .jj directory
    * @returns {Promise<boolean>}
    */
   async exists(path) {
     const fullPath = `${this.jjDir}/${path}`;
-    
+
     try {
       await this.fs.promises.stat(fullPath);
       return true;
@@ -194,7 +200,7 @@ export class Storage {
 
   /**
    * Invalidate cache
-   * 
+   *
    * @param {string} [path] - Specific path to invalidate, or all if not provided
    */
   invalidateCache(path) {

package/src/core/tag-store.js

@@ -49,7 +49,7 @@ function matchesPattern(name, pattern) {
 
 export class TagStore {
   /**
-   * @param {Object} fs - Filesystem interface
+   * @param {any} fs - Filesystem interface
    * @param {string} jjDir - Path to .jj directory
    */
   constructor(fs, jjDir) {
@@ -60,7 +60,7 @@ export class TagStore {
 
   /**
    * Loads tags from storage
-   * @returns {Promise<Object>} Map of tag name to changeId
+   * @returns {Promise<Record<string, any>>} Map of tag name to changeId
    */
   async load() {
     try {

package/src/core/user-config.js

@@ -80,6 +80,8 @@ export class UserConfig {
 
   /**
    * Deep merge two config objects (workspace overrides global)
+   * @param {any} target - Base config object
+   * @param {any} source - Overriding config object
    * @private
    */
   _deepMerge(target, source) {
@@ -171,7 +173,7 @@ export class UserConfig {
     }
 
     const parts = key.split('.');
-    const lastPart = parts.pop();
+    const lastPart = /** @type {string} */ (parts.pop());
     let target = this.config;
 
     for (const part of parts) {

package/src/core/working-copy.js

@@ -1,6 +1,6 @@
 /**
  * WorkingCopy - Manages working copy state and file tracking
- * 
+ *
  * Tracks file states (mtime, size, mode) for efficient modification detection.
  */
 
@@ -10,7 +10,7 @@ import { validateChangeId, validatePath } from '../utils/validation.js';
 export class WorkingCopy {
   /**
    * @param {Storage} storage - Storage manager instance
-   * @param {Object} fs - Filesystem implementation
+   * @param {any} fs - Filesystem implementation
    * @param {string} dir - Repository directory
    * @param {string} [workspaceId='default'] - Workspace identifier
    */
@@ -85,8 +85,8 @@ export class WorkingCopy {
 
   /**
    * Get current working copy state
-   * 
-   * @returns {Object} Working copy state
+   *
+   * @returns {Promise<Record<string, any>>} Working copy state
    */
   async getState() {
     if (!this.state) {
@@ -97,7 +97,7 @@ export class WorkingCopy {
 
   /**
    * Get current change ID
-   * 
+   *
    * @returns {string} Current change ID
    */
   getCurrentChangeId() {
@@ -111,7 +111,7 @@ export class WorkingCopy {
 
   /**
    * Set current change ID
-   * 
+   *
    * @param {string} changeId - New change ID
    */
   async setCurrentChange(changeId) {
@@ -127,7 +127,7 @@ export class WorkingCopy {
 
   /**
    * Track a file in the working copy
-   * 
+   *
    * @param {string} path - File path relative to repo root
    * @param {Object} fileState - File state (mtime, size, mode, hash)
    */
@@ -160,9 +160,9 @@ export class WorkingCopy {
 
   /**
    * Get list of modified files
-   * 
+   *
    * Uses mtime + size comparison for fast detection.
-   * 
+   *
    * @returns {Promise<Array<string>>} Array of modified file paths
    */
   async getModifiedFiles() {
@@ -198,6 +198,122 @@ export class WorkingCopy {
     return modified;
   }
 
+  /**
+   * Recursively walk the working directory on disk and return every file path
+   * relative to the repo root (v1.6).
+   *
+   * This is the foundation of automatic snapshotting: unlike listFiles() (which
+   * only returns files already tracked in state), this discovers files created
+   * out-of-band (editors, shell, git checkout). The .git and .jj metadata dirs
+   * and node_modules are always excluded.
+   *
+   * @param {object} [opts]
+   * @param {string[]} [opts.exclude] - Additional top-level directory/file names to skip
+   * @returns {Promise<Array<string>>} Repo-relative file paths (forward-slash separated)
+   */
+  async walk(opts = {}) {
+    const exclude = new Set(['.git', '.jj', 'node_modules', ...(opts.exclude || [])]);
+    /** @type {string[]} */
+    const results = [];
+
+    /**
+     * @param {string} current - Absolute directory path
+     * @param {string} prefix - Repo-relative prefix
+     */
+    const recurse = async (current, prefix) => {
+      /** @type {string[]} */
+      let entries;
+      try {
+        entries = await this.fs.promises.readdir(current);
+      } catch {
+        return; // not a readable directory
+      }
+      for (const name of entries) {
+        if (exclude.has(name)) continue;
+        const full = `${current}/${name}`;
+        const rel = prefix ? `${prefix}/${name}` : name;
+        let stats;
+        try {
+          stats = await this.fs.promises.stat(full);
+        } catch {
+          // Some in-memory filesystems don't materialize directory entries;
+          // treat an unstattable name as a possible directory and recurse.
+          await recurse(full, rel);
+          continue;
+        }
+        if (stats.isDirectory()) {
+          await recurse(full, rel);
+        } else if (stats.isFile()) {
+          results.push(rel);
+        }
+      }
+    };
+
+    await recurse(this.dir, '');
+    return results;
+  }
+
+  /**
+   * Snapshot the working directory: scan the disk, then reconcile tracked file
+   * state with what actually exists (v1.6, mirrors jj's snapshot-before-command).
+   *
+   * Newly-seen files are tracked, changed files (by mtime/size) are updated, and
+   * tracked-but-missing files are untracked. Sparse patterns are honored.
+   *
+   * @param {object} [opts]
+   * @param {string[]} [opts.exclude] - Additional names to skip while walking
+   * @returns {Promise<{added: string[], modified: string[], deleted: string[]}>}
+   */
+  async snapshot(opts = {}) {
+    if (!this.state) {
+      await this.load();
+    }
+
+    const onDisk = await this.walk(opts);
+    const trackedBefore = new Set(Object.keys(this.state.fileStates));
+    const seen = new Set();
+    /** @type {string[]} */
+    const added = [];
+    /** @type {string[]} */
+    const modified = [];
+
+    for (const rel of onDisk) {
+      // Respect sparse checkout: don't snapshot files outside the sparse set.
+      if (!this.matchesSparsePatterns(rel)) continue;
+      seen.add(rel);
+
+      let stats;
+      try {
+        stats = await this.fs.promises.stat(`${this.dir}/${rel}`);
+      } catch {
+        continue;
+      }
+
+      const prev = this.state.fileStates[rel];
+      const next = { mtime: stats.mtime, size: stats.size, mode: stats.mode };
+
+      if (!prev) {
+        this.state.fileStates[rel] = next;
+        added.push(rel);
+      } else if (prev.mtime !== stats.mtime || prev.size !== stats.size) {
+        this.state.fileStates[rel] = next;
+        modified.push(rel);
+      }
+    }
+
+    /** @type {string[]} */
+    const deleted = [];
+    for (const rel of trackedBefore) {
+      if (!seen.has(rel)) {
+        delete this.state.fileStates[rel];
+        deleted.push(rel);
+      }
+    }
+
+    await this.save();
+    return { added, modified, deleted };
+  }
+
   /**
    * List all tracked files in working copy
    *

package/src/core/workspace-manager.js

@@ -8,14 +8,14 @@
  */
 
 import { JJError } from '../utils/errors.js';
-import { validateChangeId, validatePath } from '../utils/validation.js';
+import { validateChangeId } from '../utils/validation.js';
 import { generateId } from '../utils/id-generation.js';
 import path from 'path';
 
 export class WorkspaceManager {
   /**
    * @param {Storage} storage - Storage manager instance
-   * @param {Object} fs - Filesystem implementation
+   * @param {any} fs - Filesystem implementation
    * @param {string} repoDir - Repository directory
    */
   constructor(storage, fs, repoDir) {

package/src/drivers/built-in-drivers.js

@@ -8,10 +8,10 @@
  * Deep merge for JSON objects
  * Recursively merges objects, with theirs taking precedence on conflicts
  *
- * @param {Object} base - Base object
- * @param {Object} ours - Our changes
- * @param {Object} theirs - Their changes
- * @returns {Object} Merged object
+ * @param {any} base - Base object
+ * @param {any} ours - Our changes
+ * @param {any} theirs - Their changes
+ * @returns {Record<string, any>|null} Merged object
  */
 function deepMergeJSON(base, ours, theirs) {
   // If all are identical, return any
@@ -30,7 +30,12 @@ function deepMergeJSON(base, ours, theirs) {
   }
 
   // Both sides changed - need smart merge
-  if (typeof ours !== 'object' || typeof theirs !== 'object' || Array.isArray(ours) || Array.isArray(theirs)) {
+  if (
+    typeof ours !== 'object' ||
+    typeof theirs !== 'object' ||
+    Array.isArray(ours) ||
+    Array.isArray(theirs)
+  ) {
     // Primitives or arrays - conflict
     return null;
   }
@@ -61,7 +66,12 @@ function deepMergeJSON(base, ours, theirs) {
       result[key] = oursVal;
     } else {
       // Both changed differently
-      if (typeof oursVal === 'object' && typeof theirsVal === 'object' && !Array.isArray(oursVal) && !Array.isArray(theirsVal)) {
+      if (
+        typeof oursVal === 'object' &&
+        typeof theirsVal === 'object' &&
+        !Array.isArray(oursVal) &&
+        !Array.isArray(theirsVal)
+      ) {
         // Recurse for nested objects
         const merged = deepMergeJSON(baseVal || {}, oursVal, theirsVal);
         if (merged === null) {
@@ -83,8 +93,10 @@ function deepMergeJSON(base, ours, theirs) {
  *
  * Attempts to merge JSON files intelligently by merging objects.
  * Falls back to conflict markers if merge isn't possible.
+ *
+ * @param {{ path?: string, content: { base?: string, ours?: string, theirs?: string } }} args
  */
-export async function jsonDriver({ path, content }) {
+export async function jsonDriver({ content }) {
   const { base, ours, theirs } = content;
 
   try {
@@ -106,10 +118,12 @@ export async function jsonDriver({ path, content }) {
       return {
         content: conflictContent,
         hasConflict: true,
-        conflicts: [{
-          type: 'json-merge-conflict',
-          message: 'Both sides modified the same field with different values',
-        }],
+        conflicts: [
+          {
+            type: 'json-merge-conflict',
+            message: 'Both sides modified the same field with different values',
+          },
+        ],
       };
     }
   } catch (error) {
@@ -118,10 +132,12 @@ export async function jsonDriver({ path, content }) {
     return {
       content: conflictContent,
       hasConflict: true,
-      conflicts: [{
-        type: 'json-parse-error',
-        message: `JSON parsing failed: ${error.message}`,
-      }],
+      conflicts: [
+        {
+          type: 'json-parse-error',
+          message: `JSON parsing failed: ${error.message}`,
+        },
+      ],
     };
   }
 }
@@ -133,8 +149,10 @@ export async function jsonDriver({ path, content }) {
  * - Union merge for dependencies/devDependencies
  * - Take theirs for version (semver conflicts are hard)
  * - Merge other fields intelligently
+ *
+ * @param {{ path?: string, content: { base?: string, ours?: string, theirs?: string } }} args
  */
-export async function packageJsonDriver({ path, content }) {
+export async function packageJsonDriver({ content }) {
   const { base, ours, theirs } = content;
 
   try {
@@ -147,12 +165,17 @@ export async function packageJsonDriver({ path, content }) {
 
     // Merge top-level fields
     for (const key of Object.keys({ ...oursObj, ...theirsObj })) {
-      if (key === 'dependencies' || key === 'devDependencies' || key === 'peerDependencies' || key === 'optionalDependencies') {
+      if (
+        key === 'dependencies' ||
+        key === 'devDependencies' ||
+        key === 'peerDependencies' ||
+        key === 'optionalDependencies'
+      ) {
         // Union merge dependencies
         merged[key] = {
           ...baseObj[key],
           ...oursObj[key],
-          ...theirsObj[key],  // theirs wins on conflicts
+          ...theirsObj[key], // theirs wins on conflicts
         };
       } else if (key === 'version') {
         // Version conflicts are tricky - take theirs
@@ -162,7 +185,7 @@ export async function packageJsonDriver({ path, content }) {
         merged[key] = {
           ...baseObj[key],
           ...oursObj[key],
-          ...theirsObj[key],  // theirs wins
+          ...theirsObj[key], // theirs wins
         };
       } else {
         // Other fields - use standard logic
@@ -198,10 +221,12 @@ export async function packageJsonDriver({ path, content }) {
     return {
       content: conflictContent,
       hasConflict: true,
-      conflicts: [{
-        type: 'parse-error',
-        message: `package.json parsing failed: ${error.message}`,
-      }],
+      conflicts: [
+        {
+          type: 'parse-error',
+          message: `package.json parsing failed: ${error.message}`,
+        },
+      ],
     };
   }
 }
@@ -211,8 +236,10 @@ export async function packageJsonDriver({ path, content }) {
  *
  * Note: This is a simple implementation. For production use, consider
  * using a proper YAML library like 'js-yaml'.
+ *
+ * @param {{ path?: string, content: { base?: string, ours?: string, theirs?: string } }} args
  */
-export async function yamlDriver({ path, content }) {
+export async function yamlDriver({ content }) {
   const { base, ours, theirs } = content;
 
   // Simple YAML merge - just do text-based for now
@@ -235,10 +262,12 @@ export async function yamlDriver({ path, content }) {
   return {
     content: conflictContent,
     hasConflict: true,
-    conflicts: [{
-      type: 'yaml-conflict',
-      message: 'YAML files modified on both sides',
-    }],
+    conflicts: [
+      {
+        type: 'yaml-conflict',
+        message: 'YAML files modified on both sides',
+      },
+    ],
   };
 }
 
@@ -247,8 +276,10 @@ export async function yamlDriver({ path, content }) {
  *
  * Attempts to merge markdown files by sections (headers).
  * Falls back to conflict markers for complex cases.
+ *
+ * @param {{ path?: string, content: { base?: string, ours?: string, theirs?: string } }} args
  */
-export async function markdownDriver({ path, content }) {
+export async function markdownDriver({ content }) {
   const { base, ours, theirs } = content;
 
   // Simple markdown merge - just text-based for now
@@ -272,10 +303,12 @@ export async function markdownDriver({ path, content }) {
   return {
     content: conflictContent,
     hasConflict: true,
-    conflicts: [{
-      type: 'markdown-conflict',
-      message: 'Markdown files modified on both sides',
-    }],
+    conflicts: [
+      {
+        type: 'markdown-conflict',
+        message: 'Markdown files modified on both sides',
+      },
+    ],
   };
 }
 

package/src/types.d.ts

@@ -294,6 +294,12 @@ export interface CreateJJOptions {
   backend?: string | any;
   /** Event hooks */
   hooks?: Hooks;
+  /**
+   * Automatically snapshot the working directory (disk-walk) before
+   * read/commit operations so out-of-band file changes are picked up.
+   * Defaults to `true`; set `false` to only track files written via jj.write().
+   */
+  autoSnapshot?: boolean;
 }
 
 /**
@@ -1042,6 +1048,13 @@ export interface JJ {
   edit(args: EditArgs): Promise<void>;
   status(): Promise<Status>;
   stats(): Promise<RepositoryStats>;
+  /**
+   * Snapshot the working directory (disk-walk), reconciling tracked file state
+   * and the working-copy change's content with what exists on disk (v1.6).
+   * Runs automatically before status/describe/diff/read/file.* unless the repo
+   * was created with `{ autoSnapshot: false }`.
+   */
+  snapshot(): Promise<{ added: string[]; modified: string[]; deleted: string[] }>;
 
   // History editing
   squash(args: SquashArgs): Promise<void>;
@@ -1051,6 +1064,39 @@ export interface JJ {
   unabandon(args: UnabandonArgs): Promise<void>;
   absorb(args?: AbsorbArgs): Promise<AbsorbResult>;
 
+  /**
+   * Create a change that reverses another change (matches `jj revert`, v1.5).
+   * Canonical replacement for the deprecated `backout()`.
+   */
+  revert(args: { revision?: ChangeID; change?: ChangeID; changeId?: ChangeID; target?: ChangeID; message?: string }): Promise<{
+    changeId: ChangeID;
+    description: string;
+    revertedFrom: ChangeID;
+    backedOut: ChangeID;
+    fileSnapshot: Record<string, string>;
+  }>;
+
+  /** @deprecated Use {@link JJ.revert}. Retained for backward compatibility. */
+  backout(args: { revision?: ChangeID; change?: ChangeID; changeId?: ChangeID; target?: ChangeID; message?: string }): Promise<{
+    changeId: ChangeID;
+    description: string;
+    backedOut: ChangeID;
+    fileSnapshot: Record<string, string>;
+  }>;
+
+  /** Sign a change, recording signature metadata (matches `jj sign`, v1.5). */
+  sign(args?: { revision?: ChangeID; change?: ChangeID; changeId?: ChangeID; backend?: string; key?: string }): Promise<{
+    changeId: ChangeID;
+    signed: true;
+    signature: { status: string; backend: string; key: string | null; timestamp: string };
+  }>;
+
+  /** Remove signature metadata from a change (matches `jj unsign`, v1.5). */
+  unsign(args?: { revision?: ChangeID; change?: ChangeID; changeId?: ChangeID }): Promise<{
+    changeId: ChangeID;
+    signed: false;
+  }>;
+
   // Queries
   log(opts?: LogOptions & { count?: false }): Promise<LogEntry[]>;
   log(opts: LogOptions & { count: true }): Promise<number>;
@@ -1059,6 +1105,11 @@ export interface JJ {
 
   // Operations
   undo(opts?: UndoOptions): Promise<UndoResult>;
+  /** Re-apply an operation previously reverted by {@link JJ.undo} (matches `jj redo`, v1.5). */
+  redo(): Promise<{
+    redoneOperation: { description: string; undoneOpId: OperationID };
+    restoredState: { workingCopy: ChangeID; heads: ChangeID[]; fileCount: number };
+  }>;
   operations: {
     list(opts?: { limit?: number }): Promise<Operation[]>;
     at(args: { operation: OperationID }): Promise<JJ>;
@@ -1116,6 +1167,8 @@ export interface JJ {
     set(args: BookmarkSetArgs): Promise<{ name: string; changeId: ChangeID }>;
     create(args: BookmarkCreateArgs): Promise<{ name: string; changeId: ChangeID }>;
     move(args: BookmarkMoveArgs): Promise<{ name: string; from: ChangeID; to: ChangeID }>;
+    /** Move a bookmark forward only; rejects non-descendant targets (matches `jj bookmark advance`, v1.5). */
+    advance(args: { name: string; to?: ChangeID; target?: ChangeID; changeId?: ChangeID; change?: ChangeID; revision?: ChangeID }): Promise<{ name: string; from: ChangeID; to: ChangeID }>;
     delete(args: BookmarkDeleteArgs): Promise<{ deleted: string }>;
     rename(args: BookmarkRenameArgs): Promise<{ oldName: string; newName: string; changeId: ChangeID }>;
     track(args: BookmarkTrackArgs): Promise<{ name: string; remote: string; tracking: boolean }>;
@@ -1152,6 +1205,8 @@ export interface JJ {
   file: {
     show(args: ReadArgs): Promise<string | Uint8Array>;
     list(args?: ListFilesArgs): Promise<string[]>;
+    /** Search tracked file contents (matches `jj file search`, v1.5). Regex by default. */
+    search(args: { pattern: string; changeId?: ChangeID; change?: ChangeID; kind?: 'regex' | 'substring'; path?: string }): Promise<Array<{ path: string; lineNumber: number; line: string }>>;
     write(args: WriteArgs): Promise<WriteResult>;
     move(args: MoveFileArgs): Promise<MoveResult>;
     remove(args: RemoveArgs): Promise<RemoveResult>;
@@ -1270,6 +1325,15 @@ export interface JJ {
     reset(): Promise<void>;
     clear(): Promise<void>;
   };
+
+  // Tags (immutable references; `set` is the v1.5 upsert)
+  tag: {
+    create(args: { name: string; changeId?: ChangeID }): Promise<{ name: string; changeId: ChangeID }>;
+    /** Create or move a tag (matches `jj tag set`, v1.5). */
+    set(args: { name: string; changeId?: ChangeID; change?: ChangeID; revision?: ChangeID }): Promise<{ name: string; changeId: ChangeID; updated: boolean }>;
+    list(args?: { pattern?: string }): Promise<Array<{ name: string; changeId: ChangeID }>>;
+    delete(args: { name: string }): Promise<{ deleted: string }>;
+  };
 }
 
 // ============================================================================
@@ -1290,6 +1354,8 @@ export function createJJ(options: CreateJJOptions): Promise<JJ>;
 export class JJError extends Error {
   code: string;
   suggestion?: string;
+  context: Record<string, any>;
+  details: Record<string, any>;
 
-  constructor(code: string, message: string, details?: { suggestion?: string });
+  constructor(code: string, message: string, context?: { suggestion?: string } & Record<string, any>);
 }