Modified regular file .nvmrc:
   1    1: 2224
Modified regular file app/datastore/viewer.js:
   1    1: // Datastore Viewer
   2    2: import api from '../api.js';
   3     : import izui from '../izui.js';
   4    3: 
   5    4: console.log('datastore viewer loading');
   6    5: 
   7     : // Initialize IZUI - this window is a child of settings, notify parent on close
   8     : izui.init({ canHaveChildren: false });
   9     : 
  10    6: const tables = ['addresses', 'visits', 'content', 'tags', 'blobs', 'scripts_data', 'feeds'];
  11    7: 
  12    8: let currentTable = null;
    ...
Modified regular file app/diagnostic.html:
    ...
  47   47:   <div id="output"></div>
  48   48: 
  49   49:   <script type="module">
  50     :     import izui from './izui.js';
  51     : 
  52   50:     const api = window.app;
  53   51:     const output = document.getElementById('output');
  54   52: 
  55     :     // Initialize IZUI - notify parent on close
  56     :     izui.init({ canHaveChildren: false });
  57     : 
  58   53:     function log(title, content) {
  59   54:       const section = document.createElement('div');
  60   55:       section.innerHTML = `<h2>${title}</h2><pre>${content}</pre>`;
    ...
Removed regular file app/izui.js:
   1     : /**
   2     :  * IZUI: Inverted Zooming User Interface - Minimal Implementation
   3     :  *
   4     :  * Simple parent-child window tracking for focus restoration.
   5     :  * When a child window closes, focus returns to its parent.
   6     :  *
   7     :  * See notes/izui-model.md for the full design and future plans.
   8     :  */
   9     : 
  10     : import api from './api.js';
  11     : 
  12     : const DEBUG = false;
  13     : 
  14     : /**
  15     :  * Notify parent window to take focus.
  16     :  * Called when this window is about to close/hide.
  17     :  *
  18     :  * @param {string} parentAddress - The parent window's address (source)
  19     :  */
  20     : export function notifyParentFocus(parentAddress) {
  21     :   if (!parentAddress) return;
  22     : 
  23     :   DEBUG && console.log('[IZUI] Notifying parent to focus:', parentAddress);
  24     : 
  25     :   // Publish to the parent's address so it receives the message
  26     :   api.publish('izui:focus-request', {
  27     :     from: window.location.toString()
  28     :   }, api.scopes.GLOBAL);
  29     : }
  30     : 
  31     : /**
  32     :  * Set up focus listener for this window.
  33     :  * When a child window closes, this window will receive focus.
  34     :  *
  35     :  * Call this in windows that may have children (e.g., settings).
  36     :  */
  37     : export function setupFocusListener() {
  38     :   const myAddress = window.location.toString();
  39     : 
  40     :   api.subscribe('izui:focus-request', (msg) => {
  41     :     DEBUG && console.log('[IZUI] Received focus request from:', msg?.from);
  42     : 
  43     :     // Focus this window
  44     :     if (api.window && api.window.focus) {
  45     :       api.window.focus({});
  46     :     }
  47     :   }, api.scopes.GLOBAL);
  48     : 
  49     :   DEBUG && console.log('[IZUI] Focus listener set up for:', myAddress);
  50     : }
  51     : 
  52     : /**
  53     :  * Open a child window with IZUI tracking.
  54     :  * The child will notify this window to focus when it closes.
  55     :  *
  56     :  * @param {string} address - URL to open
  57     :  * @param {Object} params - Window parameters
  58     :  * @returns {Promise<Object>} Window controller
  59     :  */
  60     : export async function openChildWindow(address, params = {}) {
  61     :   const myAddress = window.location.toString();
  62     : 
  63     :   // Track this window as the parent
  64     :   const childParams = {
  65     :     ...params,
  66     :     izuiParent: myAddress
  67     :   };
  68     : 
  69     :   DEBUG && console.log('[IZUI] Opening child window:', address, 'parent:', myAddress);
  70     : 
  71     :   const result = await api.window.open(address, childParams);
  72     :   return result;
  73     : }
  74     : 
  75     : /**
  76     :  * Handle ESC key for IZUI navigation.
  77     :  * If the window has internal navigation, handle that first.
  78     :  * Otherwise, close and notify parent.
  79     :  *
  80     :  * @param {Function} [internalHandler] - Optional handler for internal navigation
  81     :  *   Should return { handled: true } if it handled the ESC internally
  82     :  * @returns {Function} Cleanup function
  83     :  */
  84     : export function setupEscapeHandler(internalHandler) {
  85     :   const handler = async () => {
  86     :     // First, try internal navigation
  87     :     if (internalHandler) {
  88     :       const result = await internalHandler();
  89     :       if (result && result.handled) {
  90     :         DEBUG && console.log('[IZUI] Internal handler handled ESC');
  91     :         return { handled: true };
  92     :       }
  93     :     }
  94     : 
  95     :     // No internal navigation, notify parent before closing
  96     :     // The parent address is passed via window params, but we need to get it
  97     :     // For now, we just publish globally - the parent will pick it up
  98     :     notifyParentFocus(null); // Global publish
  99     : 
 100     :     DEBUG && console.log('[IZUI] ESC at root, closing');
 101     :     return { handled: false };
 102     :   };
 103     : 
 104     :   // Register with the escape API
 105     :   if (api.escape && api.escape.onEscape) {
 106     :     api.escape.onEscape(handler);
 107     :   }
 108     : 
 109     :   return () => {
 110     :     // Cleanup - currently no way to unregister escape handler
 111     :   };
 112     : }
 113     : 
 114     : /**
 115     :  * Initialize IZUI for a window.
 116     :  * Sets up focus listening and escape handling.
 117     :  *
 118     :  * @param {Object} options
 119     :  * @param {Function} [options.onEscape] - Internal escape handler
 120     :  * @param {boolean} [options.canHaveChildren=true] - Whether this window may open children
 121     :  */
 122     : export function init(options = {}) {
 123     :   const { onEscape, canHaveChildren = true } = options;
 124     : 
 125     :   if (canHaveChildren) {
 126     :     setupFocusListener();
 127     :   }
 128     : 
 129     :   if (onEscape) {
 130     :     setupEscapeHandler(onEscape);
 131     :   }
 132     : 
 133     :   DEBUG && console.log('[IZUI] Initialized for:', window.location.toString());
 134     : }
 135     : 
 136     : export default {
 137     :   init,
 138     :   setupFocusListener,
 139     :   setupEscapeHandler,
 140     :   openChildWindow,
 141     :   notifyParentFocus
 142     : };
Modified regular file app/settings/settings.js:
   1    1: import appConfig from '../config.js';
   2    2: import { createDatastoreStore } from '../utils.js';
   3    3: import api from '../api.js';
   4    4: import fc from '../features.js';
   5     : import izui from '../izui.js';
   6    5: 
   7    6: const DEBUG = api.debug;
   8    7: const clear = false;
    ...
1212 1211:       const allExtensions = [];
1213 1212: 
1214 1213:       // Get all builtin extension IDs from the loader
1215 1214:       const builtinExtIds = ['cmd', 'editor', 'groups', 'peeks', 'slides', 'windows'];
1216 1215: 
1217 1216:       // Add builtin extensions (whether running or not)
1218 1217:       builtinExtIds.forEach(extId => {
    ...
2524 2523:   datastoreNav.textContent = 'Datastore';
2525 2524:   datastoreNav.style.cursor = 'pointer';
2526 2525:   datastoreNav.addEventListener('click', () => {
2527     :     izui.openChildWindow('peek://app/datastore/viewer.html', {
     2526:     api.window.open('peek://app/datastore/viewer.html', {
2528 2527:       width: 900,
2529 2528:       height: 600,
2530 2529:       key: 'datastore-viewer'
    ...
2538 2537:   diagnosticNav.textContent = 'Diagnostic';
2539 2538:   diagnosticNav.style.cursor = 'pointer';
2540 2539:   diagnosticNav.addEventListener('click', () => {
2541     :     izui.openChildWindow('peek://app/diagnostic.html', {
     2540:     api.window.open('peek://app/diagnostic.html', {
2542 2541:       width: 900,
2543 2542:       height: 700,
2544 2543:       key: 'diagnostic-tool'
    ...
2574 2573: 
2575 2574: window.addEventListener('load', init);
2576 2575: 
2577     : // Initialize IZUI for focus restoration when child windows close
2578     : izui.init({ canHaveChildren: true });
2579     : 
2580 2576: window.addEventListener('blur', () => {
2581 2577:   console.log('core settings blur');
2582 2578: });
    ...
Modified regular file backend/tauri-mobile/src-tauri/gen/apple/Peek/ShareViewController.swift:
    ...
   9    9: /// Schema version for tracking compatibility between Rust main app and Swift Share Extension.
  10   10: /// Increment this when making schema changes that both codepaths must understand.
  11   11: /// Both Rust and Swift code should use the same version number.
  12   12: private let SCHEMA_VERSION = "12"
  13   13: 
  14   14: // MARK: - Item Types
  15   15: enum ItemType: String {
    ...
  36   36: struct TagRecord: Codable, FetchableRecord, PersistableRecord {
  37   37:     static let databaseTableName = "tags"
  38   38: 
  39   39:     var id: Int64String?
  40   40:     var name: String
  41   41:     var frequency: Int
  42   42:     var lastUsed: String
    ...
  49   49:     static let databaseTableName = "item_tags"
  50   50: 
  51   51:     var item_id: String
  52   52:     var tag_id: Int64String
  53   53:     var created_at: String
  54   54: }
  55   55: 
    ...
 226  226: 
 227  227:                     CREATE TABLE IF NOT EXISTS item_tags (
 228  228:                         item_id TEXT NOT NULL,
 229  229:                         tag_id INTEGERTEXT NOT NULL,
 230  230:                         created_at TEXT NOT NULL,
 231  231:                         PRIMARY KEY (item_id, tag_id),
 232  232:                         FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
    ...
 272  272: 
 273  273:                     CREATE TABLE IF NOT EXISTS item_tags (
 274  274:                         item_id TEXT NOT NULL,
 275  275:                         tag_id INTEGERTEXT NOT NULL,
 276  276:                         created_at TEXT NOT NULL,
 277  277:                         PRIMARY KEY (item_id, tag_id),
 278  278:                         FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
    ...
 289  289:                 print("[DB] Metadata column added")
 290  290:             }
 291  291: 
 292     :             // Create tags and settings tables (always needed)
      292:             // Create settings table first (needed for migration tracking)
 293  293:             try db.execute(sql: """
 294     :                 CREATE TABLE IF NOT EXISTS tags (
 295     :                     id INTEGER PRIMARY KEY AUTOINCREMENT,
 296     :                     name TEXT NOT NULL UNIQUE,
 297     :                     frequency INTEGER NOT NULL DEFAULT 0,
 298     :                     lastUsed TEXT NOT NULL,
 299     :                     frecencyScore REAL NOT NULL DEFAULT 0.0,
 300     :                     createdAt TEXT NOT NULL,
 301     :                     updatedAt TEXT NOT NULL
 302     :                 );
 303     : 
 304  294:                 CREATE TABLE IF NOT EXISTS settings (
 305  295:                     key TEXT PRIMARY KEY,
 306  296:                     value TEXT NOT NULL
 307  297:                 );
      298:             """)
      299: 
      300:             // Migrate tags.id from INTEGER to TEXT (for existing installs with old schema)
      301:             // Check if tags table exists and has INTEGER id column
      302:             if try db.tableExists("tags") {
      303:                 let tagsHasIntegerId = try db.columns(in: "tags")
      304:                     .contains { $0.name == "id" && $0.type.uppercased() == "INTEGER" }
      305: 
      306:                 if tagsHasIntegerId {
      307:                     print("[DB] Migrating tags.id from INTEGER to TEXT...")
      308: 
      309:                     try db.inSavepoint {
      310:                         // Step 1: Create temp mapping table
      311:                         try db.execute(sql: """
      312:                             CREATE TEMP TABLE tag_id_mapping (
      313:                                 old_id INTEGER PRIMARY KEY,
      314:                                 new_id TEXT NOT NULL
      315:                             );
      316:                         """)
      317: 
      318:                         // Step 2: Populate mapping with generated TEXT IDs
      319:                         let oldIds = try Int64.fetchAll(db, sql: "SELECT id FROM tags")
      320:                         for oldId in oldIds {
      321:                             let newId = generateTagId()
      322:                             try db.execute(sql: "INSERT INTO tag_id_mapping (old_id, new_id) VALUES (?, ?)",
      323:                                           arguments: [oldId, newId])
      324:                         }
      325: 
      326:                         // Step 3: Create new tables with TEXT schema
      327:                         try db.execute(sql: """
      328:                             CREATE TABLE tags_new (
      329:                                 id TEXT PRIMARY KEY,
      330:                                 name TEXT NOT NULL UNIQUE,
      331:                                 frequency INTEGER NOT NULL DEFAULT 0,
      332:                                 lastUsed TEXT NOT NULL,
      333:                                 frecencyScore REAL NOT NULL DEFAULT 0.0,
      334:                                 createdAt TEXT NOT NULL,
      335:                                 updatedAt TEXT NOT NULL
      336:                             );
      337: 
      338:                             CREATE TABLE item_tags_new (
      339:                                 item_id TEXT NOT NULL,
      340:                                 tag_id TEXT NOT NULL,
      341:                                 created_at TEXT NOT NULL,
      342:                                 PRIMARY KEY (item_id, tag_id),
      343:                                 FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
      344:                                 FOREIGN KEY (tag_id) REFERENCES tags_new(id) ON DELETE CASCADE
      345:                             );
      346:                         """)
      347: 
      348:                         // Step 4: Copy data using mapping
      349:                         try db.execute(sql: """
      350:                             INSERT INTO tags_new (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt)
      351:                             SELECT m.new_id, t.name, t.frequency, t.lastUsed, t.frecencyScore, t.createdAt, t.updatedAt
      352:                             FROM tags t
      353:                             JOIN tag_id_mapping m ON t.id = m.old_id;
      354: 
      355:                             INSERT INTO item_tags_new (item_id, tag_id, created_at)
      356:                             SELECT it.item_id, m.new_id, it.created_at
      357:                             FROM item_tags it
      358:                             JOIN tag_id_mapping m ON it.tag_id = m.old_id;
      359:                         """)
      360: 
      361:                         // Step 5: Swap tables
      362:                         try db.execute(sql: """
      363:                             DROP TABLE item_tags;
      364:                             DROP TABLE tags;
      365:                             ALTER TABLE tags_new RENAME TO tags;
      366:                             ALTER TABLE item_tags_new RENAME TO item_tags;
      367: 
      368:                             CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name);
      369:                             CREATE INDEX IF NOT EXISTS idx_tags_frecency ON tags(frecencyScore DESC);
      370: 
      371:                             DROP TABLE IF EXISTS tag_id_mapping;
      372:                         """)
      373: 
      374:                         print("[DB] Tags INTEGER→TEXT migration completed successfully")
      375:                         return .commit
      376:                     }
      377:                 }
      378:             }
      379: 
      380:             // Create tags table (for fresh install or if migration skipped)
      381:             if !(try db.tableExists("tags")) {
      382:                 try db.execute(sql: """
      383:                     CREATE TABLE IF NOT EXISTS tags (
      384:                         id TEXT PRIMARY KEY,
      385:                         name TEXT NOT NULL UNIQUE,
      386:                         frequency INTEGER NOT NULL DEFAULT 0,
      387:                         lastUsed TEXT NOT NULL,
      388:                         frecencyScore REAL NOT NULL DEFAULT 0.0,
      389:                         createdAt TEXT NOT NULL,
      390:                         updatedAt TEXT NOT NULL
      391:                     );
      392: 
      393:                     CREATE TABLE IF NOT EXISTS item_tags (
      394:                         item_id TEXT NOT NULL,
      395:                         tag_id TEXT NOT NULL,
      396:                         created_at TEXT NOT NULL,
      397:                         PRIMARY KEY (item_id, tag_id),
      398:                         FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
      399:                         FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
      400:                     );
      401: 
      402:                     CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name);
      403:                     CREATE INDEX IF NOT EXISTS idx_tags_frecency ON tags(frecencyScore DESC);
      404:                 """)
      405:             }
      406: 
      407:             // Create blobs table and indexes
 308  408:             try db.execute(sql: """
 309  409:                 CREATE TABLE IF NOT EXISTS blobs (
 310  410:                     id TEXT PRIMARY KEY,
 311  411:                     item_id TEXT NOT NULL,
    ...
 323  423:                 CREATE INDEX IF NOT EXISTS idx_items_url ON items(url);
 324  424:                 CREATE INDEX IF NOT EXISTS idx_items_deleted ON items(deleted_at);
 325  425:                 CREATE INDEX IF NOT EXISTS idx_items_sync_id ON items(sync_id);
 326     :                 CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name);
 327     :                 CREATE INDEX IF NOT EXISTS idx_tags_frecency ON tags(frecencyScore DESC);
 328  426:                 CREATE INDEX IF NOT EXISTS idx_blobs_item_id ON blobs(item_id);
 329  427:             """)
 330  428:         }
    ...
 380  478:                 let wwwDomainPattern = "%://www.\(domain)/%"
 381  479:                 let wwwDomainPatternRoot = "%://www.\(domain)"
 382  480: 
 383  481:                 let domainTagIds = try Int64String.fetchSet(db, sql: """
 384  482:                     SELECT DISTINCT it.tag_id
 385  483:                     FROM item_tags it
 386  484:                     JOIN items i ON it.item_id = i.id
    ...
 391  489: 
 392  490:                 // Apply 2x multiplier to tags used on same-domain URLs
 393  491:                 let boostedTags = records.map { record -> TagStats in
 394  492:                     let boostedScore = domainTagIds.contains(record.id ?? -1"")
 395  493:                         ? record.frecencyScore * 2.0
 396  494:                         : record.frecencyScore
 397  495:                     return TagStats(
    ...
 497  595:                 // Add tags
 498  596:                 for tagName in tags {
 499  597:                     // Get or create tag
 500  598:                     var tagId: Int64String
 501  599: 
 502  600:                     if let existingTag = try TagRecord.filter(Column("name") == tagName).fetchOne(db) {
 503  601:                         tagId = existingTag.id!
    ...
 512  610:                         """, arguments: [newFrequency, now, frecency, now, existingTag.id!])
 513  611:                     } else {
 514  612:                         // Create new tag
      613:                         let newTagId = generateTagId()
 515  614:                         let frecency = calculateFrecency(frequency: 1, lastUsed: now)
 516  615:                         let newTag = TagRecord(id: nilnewTagId, name: tagName, frequency: 1, lastUsed: now, frecencyScore: frecency, createdAt: now, updatedAt: now)
 517  616:                         try newTag.insert(db)
 518  617:                         tagId = db.lastInsertedRowIDnewTagId
 519  618:                     }
 520  619: 
 521  620:                     // Create item-tag association
    ...
 566  665: 
 567  666:                 // Add tags
 568  667:                 for tagName in tags {
 569  668:                     var tagId: Int64String
 570  669:                     let isNewToItem = !existingTagNames.contains(tagName)
 571  670: 
 572  671:                     if let existingTag = try TagRecord.filter(Column("name") == tagName).fetchOne(db) {
    ...
 588  687:                             """, arguments: [now, frecency, now, existingTag.id!])
 589  688:                         }
 590  689:                     } else {
      690:                         let newTagId = generateTagId()
 591  691:                         let frecency = calculateFrecency(frequency: 1, lastUsed: now)
 592  692:                         let newTag = TagRecord(id: nilnewTagId, name: tagName, frequency: 1, lastUsed: now, frecencyScore: frecency, createdAt: now, updatedAt: now)
 593  693:                         try newTag.insert(db)
 594  694:                         tagId = db.lastInsertedRowIDnewTagId
 595  695:                     }
 596  696: 
 597  697:                     let itemTag = ItemTagRecord(item_id: imageId, tag_id: tagId, created_at: now)
    ...
 688  788:                 // Add tags
 689  789:                 for tagName in tags {
 690  790:                     // Get or create tag
 691  791:                     var tagId: Int64String
 692  792:                     // Only increment frequency if this tag is new to this item
 693  793:                     let isNewToItem = !existingTagNames.contains(tagName)
 694  794: 
    ...
 714  814:                         }
 715  815:                     } else {
 716  816:                         // Create new tag
      817:                         let newTagId = generateTagId()
 717  818:                         let frecency = calculateFrecency(frequency: 1, lastUsed: now)
 718  819:                         let newTag = TagRecord(id: nilnewTagId, name: tagName, frequency: 1, lastUsed: now, frecencyScore: frecency, createdAt: now, updatedAt: now)
 719  820:                         try newTag.insert(db)
 720  821:                         tagId = db.lastInsertedRowIDnewTagId
 721  822:                     }
 722  823: 
 723  824:                     // Create item-tag association
    ...
 946 1047: 
 947 1048:         return Double(frequency) * 10.0 * decayFactor
 948 1049:     }
     1050: 
     1051:     /// Generate a unique tag ID in format: tag_{timestamp}_{random9}
     1052:     private func generateTagId() -> String {
     1053:         let timestamp = Int(Date().timeIntervalSince1970 * 1000)
     1054:         let random = UUID().uuidString.prefix(9).lowercased()
     1055:         return "tag_\(timestamp)_\(random)"
     1056:     }
 949 1057: }
 950 1058: 
 951 1059: // MARK: - ISO8601 Formatter Extension
    ...
Modified regular file backend/tauri-mobile/src-tauri/src/lib.rs:
    ...
 918  918: /// Schema version for tracking compatibility between Rust main app and Swift Share Extension.
 919  919: /// Increment this when making schema changes that both codepaths must understand.
 920  920: /// Both Rust and Swift code should use the same version number.
 921  921: const SCHEMA_VERSION: &str = "12";
 922  922: 
 923  923: fn ensure_database_initialized() -> Result<(), String> {
 924  924:     let mut init_result: Result<(), String> = Ok(());
    ...
1037 1037:                 );
1038 1038: 
1039 1039:                 CREATE TABLE IF NOT EXISTS tags (
1040 1040:                     id INTEGERTEXT PRIMARY KEY AUTOINCREMENT,
1041 1041:                     name TEXT NOT NULL UNIQUE,
1042 1042:                     frequency INTEGER NOT NULL DEFAULT 0,
1043 1043:                     lastUsed TEXT NOT NULL,
    ...
1048 1048: 
1049 1049:                 CREATE TABLE IF NOT EXISTS item_tags (
1050 1050:                     item_id TEXT NOT NULL,
1051 1051:                     tag_id INTEGERTEXT NOT NULL,
1052 1052:                     created_at TEXT NOT NULL,
1053 1053:                     PRIMARY KEY (item_id, tag_id),
1054 1054:                     FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
    ...
1203 1203:             }
1204 1204:         }
1205 1205: 
1206     :         // Ensure tags and settings tables exist (for migration case)
     1206:         // Ensure settings table exists (for migration case)
1207 1207:         if let Err(e) = conn.execute_batch(
1208 1208:             "
1209     :             CREATE TABLE IF NOT EXISTS tags (
1210     :                 id INTEGER PRIMARY KEY AUTOINCREMENT,
1211     :                 name TEXT NOT NULL UNIQUE,
1212     :                 frequency INTEGER NOT NULL DEFAULT 0,
1213     :                 lastUsed TEXT NOT NULL,
1214     :                 frecencyScore REAL NOT NULL DEFAULT 0.0,
1215     :                 createdAt TEXT NOT NULL,
1216     :                 updatedAt TEXT NOT NULL
1217     :             );
1218     : 
1219 1209:             CREATE TABLE IF NOT EXISTS settings (
1220 1210:                 key TEXT PRIMARY KEY,
1221 1211:                 value TEXT NOT NULL
1222 1212:             );
1223     : 
1224     :             CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name);
1225     :             CREATE INDEX IF NOT EXISTS idx_tags_frecency ON tags(frecencyScore DESC);
1226 1213:             ",
1227 1214:         ) {
1228     :             init_result = Err(format!("Failed to ensure auxiliary tables: {}", e));
     1215:             init_result = Err(format!("Failed to ensure settings table: {}", e));
1229 1216:             return;
1230 1217:         }
1231 1218: 
     1219:         // Migrate tags.id from INTEGER to TEXT (for existing installs with old schema)
     1220:         // Check if tags table exists and has INTEGER id column
     1221:         let tags_has_integer_id: bool = conn
     1222:             .query_row(
     1223:                 "SELECT type FROM pragma_table_info('tags') WHERE name='id'",
     1224:                 [],
     1225:                 |row| row.get::<_, String>(0),
     1226:             )
     1227:             .map(|t| t.to_uppercase() == "INTEGER")
     1228:             .unwrap_or(false);
     1229: 
     1230:         if tags_has_integer_id {
     1231:             ios_log("Migrating tags.id from INTEGER to TEXT...");
     1232: 
     1233:             // Use savepoint for atomic rollback on error
     1234:             if let Err(e) = conn.execute("SAVEPOINT before_tag_migration", []) {
     1235:                 ios_log(&format!("Failed to create savepoint: {}", e));
     1236:             } else {
     1237:                 let migration_result: Result<(), String> = (|| {
     1238:                     // Step 1: Create temp mapping table
     1239:                     conn.execute_batch(
     1240:                         "CREATE TEMP TABLE tag_id_mapping (
     1241:                             old_id INTEGER PRIMARY KEY,
     1242:                             new_id TEXT NOT NULL
     1243:                         );"
     1244:                     ).map_err(|e| format!("Failed to create mapping table: {}", e))?;
     1245: 
     1246:                     // Step 2: Populate mapping with generated TEXT IDs
     1247:                     let mut stmt = conn.prepare("SELECT id FROM tags")
     1248:                         .map_err(|e| format!("Failed to prepare tag select: {}", e))?;
     1249:                     let old_ids: Vec<i64> = stmt
     1250:                         .query_map([], |row| row.get::<_, i64>(0))
     1251:                         .map_err(|e| format!("Failed to query tags: {}", e))?
     1252:                         .filter_map(|r| r.ok())
     1253:                         .collect();
     1254:                     drop(stmt);
     1255: 
     1256:                     for old_id in old_ids {
     1257:                         let new_id = generate_tag_id();
     1258:                         conn.execute(
     1259:                             "INSERT INTO tag_id_mapping (old_id, new_id) VALUES (?, ?)",
     1260:                             params![old_id, new_id],
     1261:                         ).map_err(|e| format!("Failed to insert mapping: {}", e))?;
     1262:                     }
     1263: 
     1264:                     // Step 3: Create new tables with TEXT schema
     1265:                     conn.execute_batch(
     1266:                         "CREATE TABLE tags_new (
     1267:                             id TEXT PRIMARY KEY,
     1268:                             name TEXT NOT NULL UNIQUE,
     1269:                             frequency INTEGER NOT NULL DEFAULT 0,
     1270:                             lastUsed TEXT NOT NULL,
     1271:                             frecencyScore REAL NOT NULL DEFAULT 0.0,
     1272:                             createdAt TEXT NOT NULL,
     1273:                             updatedAt TEXT NOT NULL
     1274:                         );
     1275: 
     1276:                         CREATE TABLE item_tags_new (
     1277:                             item_id TEXT NOT NULL,
     1278:                             tag_id TEXT NOT NULL,
     1279:                             created_at TEXT NOT NULL,
     1280:                             PRIMARY KEY (item_id, tag_id),
     1281:                             FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
     1282:                             FOREIGN KEY (tag_id) REFERENCES tags_new(id) ON DELETE CASCADE
     1283:                         );"
     1284:                     ).map_err(|e| format!("Failed to create new tables: {}", e))?;
     1285: 
     1286:                     // Step 4: Copy data using mapping
     1287:                     conn.execute_batch(
     1288:                         "INSERT INTO tags_new (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt)
     1289:                         SELECT m.new_id, t.name, t.frequency, t.lastUsed, t.frecencyScore, t.createdAt, t.updatedAt
     1290:                         FROM tags t
     1291:                         JOIN tag_id_mapping m ON t.id = m.old_id;
     1292: 
     1293:                         INSERT INTO item_tags_new (item_id, tag_id, created_at)
     1294:                         SELECT it.item_id, m.new_id, it.created_at
     1295:                         FROM item_tags it
     1296:                         JOIN tag_id_mapping m ON it.tag_id = m.old_id;"
     1297:                     ).map_err(|e| format!("Failed to copy data: {}", e))?;
     1298: 
     1299:                     // Step 5: Swap tables
     1300:                     conn.execute_batch(
     1301:                         "DROP TABLE item_tags;
     1302:                         DROP TABLE tags;
     1303:                         ALTER TABLE tags_new RENAME TO tags;
     1304:                         ALTER TABLE item_tags_new RENAME TO item_tags;
     1305: 
     1306:                         CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name);
     1307:                         CREATE INDEX IF NOT EXISTS idx_tags_frecency ON tags(frecencyScore DESC);"
     1308:                     ).map_err(|e| format!("Failed to swap tables: {}", e))?;
     1309: 
     1310:                     // Cleanup temp table
     1311:                     let _ = conn.execute("DROP TABLE IF EXISTS tag_id_mapping", []);
     1312: 
     1313:                     Ok(())
     1314:                 })();
     1315: 
     1316:                 match migration_result {
     1317:                     Ok(()) => {
     1318:                         let _ = conn.execute("RELEASE SAVEPOINT before_tag_migration", []);
     1319:                         ios_log("Tags INTEGER→TEXT migration completed successfully");
     1320:                     }
     1321:                     Err(e) => {
     1322:                         ios_log(&format!("Tags migration failed, rolling back: {}", e));
     1323:                         let _ = conn.execute("ROLLBACK TO SAVEPOINT before_tag_migration", []);
     1324:                         let _ = conn.execute("RELEASE SAVEPOINT before_tag_migration", []);
     1325:                     }
     1326:                 }
     1327:             }
     1328:         }
     1329: 
     1330:         // Ensure tags table exists (for fresh install or if migration skipped)
     1331:         let has_tags_table: bool = conn
     1332:             .query_row(
     1333:                 "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='tags'",
     1334:                 [],
     1335:                 |row| row.get::<_, i64>(0),
     1336:             )
     1337:             .unwrap_or(0) > 0;
     1338: 
     1339:         if !has_tags_table {
     1340:             if let Err(e) = conn.execute_batch(
     1341:                 "
     1342:                 CREATE TABLE IF NOT EXISTS tags (
     1343:                     id TEXT PRIMARY KEY,
     1344:                     name TEXT NOT NULL UNIQUE,
     1345:                     frequency INTEGER NOT NULL DEFAULT 0,
     1346:                     lastUsed TEXT NOT NULL,
     1347:                     frecencyScore REAL NOT NULL DEFAULT 0.0,
     1348:                     createdAt TEXT NOT NULL,
     1349:                     updatedAt TEXT NOT NULL
     1350:                 );
     1351: 
     1352:                 CREATE TABLE IF NOT EXISTS item_tags (
     1353:                     item_id TEXT NOT NULL,
     1354:                     tag_id TEXT NOT NULL,
     1355:                     created_at TEXT NOT NULL,
     1356:                     PRIMARY KEY (item_id, tag_id),
     1357:                     FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
     1358:                     FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
     1359:                 );
     1360: 
     1361:                 CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name);
     1362:                 CREATE INDEX IF NOT EXISTS idx_tags_frecency ON tags(frecencyScore DESC);
     1363:                 ",
     1364:             ) {
     1365:                 init_result = Err(format!("Failed to create tags tables: {}", e));
     1366:                 return;
     1367:             }
     1368:         }
     1369: 
1232 1370:         // One-time dedup migration: remove duplicate items
1233 1371:         let dedup_done: bool = conn
1234 1372:             .query_row(
    ...
1467 1605:     frequency as f64 * 10.0 * decay_factor
1468 1606: }
1469 1607: 
     1608: // Generate a unique tag ID in format: tag_{timestamp}_{random9}
     1609: fn generate_tag_id() -> String {
     1610:     use std::time::{SystemTime, UNIX_EPOCH};
     1611:     let timestamp = SystemTime::now()
     1612:         .duration_since(UNIX_EPOCH)
     1613:         .unwrap()
     1614:         .as_millis();
     1615:     let uuid = uuid::Uuid::new_v4().to_string();
     1616:     let random = &uuid[0..9]; // First 9 chars of UUID
     1617:     format!("tag_{}_{}", timestamp, random)
     1618: }
     1619: 
1470 1620: // Helper to get webhook config
1471 1621: fn get_webhook_config() -> (Option<String>, Option<String>) {
1472 1622:     let config = load_profile_config();
    ...
1915 2065:     // Add tags
1916 2066:     for tag_name in &tags {
1917 2067:         // Get or create tag
1918 2068:         let tag_id: i64String = match conn.query_row(
1919 2069:             "SELECT id FROM tags WHERE name = ?",
1920 2070:             params![tag_name],
1921 2071:             |row| row.get(0),
    ...
1925 2075:                 let frequency: u32 = conn
1926 2076:                     .query_row(
1927 2077:                         "SELECT frequency FROM tags WHERE id = ?",
1928 2078:                         params![&id],
1929 2079:                         |row| row.get(0),
1930 2080:                     )
1931 2081:                     .unwrap_or(0);
    ...
1935 2085: 
1936 2086:                 conn.execute(
1937 2087:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
1938 2088:                     params![new_frequency, &now, frecency, &now, &id],
1939 2089:                 )
1940 2090:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
1941 2091: 
1942 2092:                 id
1943 2093:             }
1944 2094:             Err(_) => {
1945 2095:                 // Create new tag
     2096:                 let new_tag_id = generate_tag_id();
1946 2097:                 let frecency = calculate_frecency(1, &now);
1947 2098:                 conn.execute(
1948 2099:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
1949 2100:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
1950 2101:                 )
1951 2102:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
1952 2103: 
1953 2104:                 conn.last_insert_rowid()new_tag_id
1954 2105:             }
1955 2106:         };
1956 2107: 
    ...
2025 2176:         .prepare("SELECT id, name, frequency, lastUsed, frecencyScore FROM tags")
2026 2177:         .map_err(|e| format!("Failed to prepare query: {}", e))?;
2027 2178: 
2028 2179:     let tags_with_ids: Vec<(i64String, TagStats)> = stmt
2029 2180:         .query_map([], |row| {
2030 2181:             Ok((
2031 2182:                 row.get(0)?,
    ...
2057 2208:         )
2058 2209:         .map_err(|e| format!("Failed to prepare domain query: {}", e))?;
2059 2210: 
2060 2211:     let domain_tag_ids: std::collections::HashSet<i64String> = domain_stmt
2061 2212:         .query_map(
2062 2213:             params![&domain_pattern, &domain_pattern_root, &www_domain_pattern, &www_domain_pattern_root],
2063 2214:             |row| row.get(0),
    ...
2213 2364:     // Add only the tags that are new to this item
2214 2365:     for tag_name in &tags_to_add {
2215 2366:         // Get or create tag
2216 2367:         let tag_id: i64String = match conn.query_row(
2217 2368:             "SELECT id FROM tags WHERE name = ?",
2218 2369:             params![tag_name],
2219 2370:             |row| row.get(0),
    ...
2223 2374:                 let frequency: u32 = conn
2224 2375:                     .query_row(
2225 2376:                         "SELECT frequency FROM tags WHERE id = ?",
2226 2377:                         params![&existing_id],
2227 2378:                         |row| row.get(0),
2228 2379:                     )
2229 2380:                     .unwrap_or(0);
    ...
2233 2384: 
2234 2385:                 conn.execute(
2235 2386:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
2236 2387:                     params![new_frequency, &now, frecency, &now, &existing_id],
2237 2388:                 )
2238 2389:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
2239 2390: 
2240 2391:                 existing_id
2241 2392:             }
2242 2393:             Err(_) => {
2243 2394:                 // Create new tag
     2395:                 let new_tag_id = generate_tag_id();
2244 2396:                 let frecency = calculate_frecency(1, &now);
2245 2397:                 conn.execute(
2246 2398:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
2247 2399:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
2248 2400:                 )
2249 2401:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
2250 2402: 
2251 2403:                 conn.last_insert_rowid()new_tag_id
2252 2404:             }
2253 2405:         };
2254 2406: 
    ...
2339 2491:     // Add only the tags that are new to this item
2340 2492:     for tag_name in &tags_to_add {
2341 2493:         // Get or create tag
2342 2494:         let tag_id: i64String = match conn.query_row(
2343 2495:             "SELECT id FROM tags WHERE name = ?",
2344 2496:             params![tag_name],
2345 2497:             |row| row.get(0),
    ...
2349 2501:                 let frequency: u32 = conn
2350 2502:                     .query_row(
2351 2503:                         "SELECT frequency FROM tags WHERE id = ?",
2352 2504:                         params![&existing_id],
2353 2505:                         |row| row.get(0),
2354 2506:                     )
2355 2507:                     .unwrap_or(0);
    ...
2359 2511: 
2360 2512:                 conn.execute(
2361 2513:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
2362 2514:                     params![new_frequency, &now, frecency, &now, &existing_id],
2363 2515:                 )
2364 2516:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
2365 2517: 
2366 2518:                 existing_id
2367 2519:             }
2368 2520:             Err(_) => {
2369 2521:                 // Create new tag
     2522:                 let new_tag_id = generate_tag_id();
2370 2523:                 let frecency = calculate_frecency(1, &now);
2371 2524:                 conn.execute(
2372 2525:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
2373 2526:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
2374 2527:                 )
2375 2528:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
2376 2529: 
2377 2530:                 conn.last_insert_rowid()new_tag_id
2378 2531:             }
2379 2532:         };
2380 2533: 
    ...
2439 2592: 
2440 2593:     // Add tags
2441 2594:     for tag_name in &all_tags {
2442 2595:         let tag_id: i64String = match conn.query_row(
2443 2596:             "SELECT id FROM tags WHERE name = ?",
2444 2597:             params![tag_name],
2445 2598:             |row| row.get(0),
    ...
2448 2601:                 let frequency: u32 = conn
2449 2602:                     .query_row(
2450 2603:                         "SELECT frequency FROM tags WHERE id = ?",
2451 2604:                         params![&existing_id],
2452 2605:                         |row| row.get(0),
2453 2606:                     )
2454 2607:                     .unwrap_or(0);
    ...
2458 2611: 
2459 2612:                 conn.execute(
2460 2613:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
2461 2614:                     params![new_frequency, &now, frecency, &now, &existing_id],
2462 2615:                 )
2463 2616:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
2464 2617: 
2465 2618:                 existing_id
2466 2619:             }
2467 2620:             Err(_) => {
     2621:                 let new_tag_id = generate_tag_id();
2468 2622:                 let frecency = calculate_frecency(1, &now);
2469 2623:                 conn.execute(
2470 2624:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
2471 2625:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
2472 2626:                 )
2473 2627:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
2474 2628: 
2475 2629:                 conn.last_insert_rowid()new_tag_id
2476 2630:             }
2477 2631:         };
2478 2632: 
    ...
2516 2670: 
2517 2671:     // Add tags
2518 2672:     for tag_name in &tags {
2519 2673:         let tag_id: i64String = match conn.query_row(
2520 2674:             "SELECT id FROM tags WHERE name = ?",
2521 2675:             params![tag_name],
2522 2676:             |row| row.get(0),
    ...
2525 2679:                 let frequency: u32 = conn
2526 2680:                     .query_row(
2527 2681:                         "SELECT frequency FROM tags WHERE id = ?",
2528 2682:                         params![&existing_id],
2529 2683:                         |row| row.get(0),
2530 2684:                     )
2531 2685:                     .unwrap_or(0);
    ...
2535 2689: 
2536 2690:                 conn.execute(
2537 2691:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
2538 2692:                     params![new_frequency, &now, frecency, &now, &existing_id],
2539 2693:                 )
2540 2694:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
2541 2695: 
2542 2696:                 existing_id
2543 2697:             }
2544 2698:             Err(_) => {
     2699:                 let new_tag_id = generate_tag_id();
2545 2700:                 let frecency = calculate_frecency(1, &now);
2546 2701:                 conn.execute(
2547 2702:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
2548 2703:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
2549 2704:                 )
2550 2705:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
2551 2706: 
2552 2707:                 conn.last_insert_rowid()new_tag_id
2553 2708:             }
2554 2709:         };
2555 2710: 
    ...
2727 2882: 
2728 2883:     // Add new tags
2729 2884:     for tag_name in &tags_to_add {
2730 2885:         let tag_id: i64String = match conn.query_row(
2731 2886:             "SELECT id FROM tags WHERE name = ?",
2732 2887:             params![tag_name],
2733 2888:             |row| row.get(0),
    ...
2736 2891:                 let frequency: u32 = conn
2737 2892:                     .query_row(
2738 2893:                         "SELECT frequency FROM tags WHERE id = ?",
2739 2894:                         params![&existing_id],
2740 2895:                         |row| row.get(0),
2741 2896:                     )
2742 2897:                     .unwrap_or(0);
    ...
2746 2901: 
2747 2902:                 conn.execute(
2748 2903:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
2749 2904:                     params![new_frequency, &now, frecency, &now, &existing_id],
2750 2905:                 )
2751 2906:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
2752 2907: 
2753 2908:                 existing_id
2754 2909:             }
2755 2910:             Err(_) => {
     2911:                 let new_tag_id = generate_tag_id();
2756 2912:                 let frecency = calculate_frecency(1, &now);
2757 2913:                 conn.execute(
2758 2914:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
2759 2915:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
2760 2916:                 )
2761 2917:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
2762 2918: 
2763 2919:                 conn.last_insert_rowid()new_tag_id
2764 2920:             }
2765 2921:         };
2766 2922: 
    ...
2851 3007: 
2852 3008:     // Add new tags
2853 3009:     for tag_name in &tags_to_add {
2854 3010:         let tag_id: i64String = match conn.query_row(
2855 3011:             "SELECT id FROM tags WHERE name = ?",
2856 3012:             params![tag_name],
2857 3013:             |row| row.get(0),
    ...
2860 3016:                 let frequency: u32 = conn
2861 3017:                     .query_row(
2862 3018:                         "SELECT frequency FROM tags WHERE id = ?",
2863 3019:                         params![&existing_id],
2864 3020:                         |row| row.get(0),
2865 3021:                     )
2866 3022:                     .unwrap_or(0);
    ...
2870 3026: 
2871 3027:                 conn.execute(
2872 3028:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
2873 3029:                     params![new_frequency, &now, frecency, &now, &existing_id],
2874 3030:                 )
2875 3031:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
2876 3032: 
2877 3033:                 existing_id
2878 3034:             }
2879 3035:             Err(_) => {
     3036:                 let new_tag_id = generate_tag_id();
2880 3037:                 let frecency = calculate_frecency(1, &now);
2881 3038:                 conn.execute(
2882 3039:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
2883 3040:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
2884 3041:                 )
2885 3042:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
2886 3043: 
2887 3044:                 conn.last_insert_rowid()new_tag_id
2888 3045:             }
2889 3046:         };
2890 3047: 
    ...
2959 3116: 
2960 3117:     // Add tags
2961 3118:     for tag_name in &tags {
2962 3119:         let tag_id: i64String = match conn.query_row(
2963 3120:             "SELECT id FROM tags WHERE name = ?",
2964 3121:             params![tag_name],
2965 3122:             |row| row.get(0),
    ...
2968 3125:                 let frequency: u32 = conn
2969 3126:                     .query_row(
2970 3127:                         "SELECT frequency FROM tags WHERE id = ?",
2971 3128:                         params![&existing_id],
2972 3129:                         |row| row.get(0),
2973 3130:                     )
2974 3131:                     .unwrap_or(0);
    ...
2978 3135: 
2979 3136:                 conn.execute(
2980 3137:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
2981 3138:                     params![new_frequency, &now, frecency, &now, &existing_id],
2982 3139:                 )
2983 3140:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
2984 3141: 
2985 3142:                 existing_id
2986 3143:             }
2987 3144:             Err(_) => {
     3145:                 let new_tag_id = generate_tag_id();
2988 3146:                 let frecency = calculate_frecency(1, &now);
2989 3147:                 conn.execute(
2990 3148:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
2991 3149:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
2992 3150:                 )
2993 3151:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
2994 3152: 
2995 3153:                 conn.last_insert_rowid()new_tag_id
2996 3154:             }
2997 3155:         };
2998 3156: 
    ...
3169 3327: 
3170 3328:     // Add new tags
3171 3329:     for tag_name in &tags_to_add {
3172 3330:         let tag_id: i64String = match conn.query_row(
3173 3331:             "SELECT id FROM tags WHERE name = ?",
3174 3332:             params![tag_name],
3175 3333:             |row| row.get(0),
    ...
3178 3336:                 let frequency: u32 = conn
3179 3337:                     .query_row(
3180 3338:                         "SELECT frequency FROM tags WHERE id = ?",
3181 3339:                         params![&existing_id],
3182 3340:                         |row| row.get(0),
3183 3341:                     )
3184 3342:                     .unwrap_or(0);
    ...
3188 3346: 
3189 3347:                 conn.execute(
3190 3348:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
3191 3349:                     params![new_frequency, &now, frecency, &now, &existing_id],
3192 3350:                 )
3193 3351:                 .map_err(|e| format!("Failed to update tag: {}", e))?;
3194 3352: 
3195 3353:                 existing_id
3196 3354:             }
3197 3355:             Err(_) => {
     3356:                 let new_tag_id = generate_tag_id();
3198 3357:                 let frecency = calculate_frecency(1, &now);
3199 3358:                 conn.execute(
3200 3359:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
3201 3360:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
3202 3361:                 )
3203 3362:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
3204 3363: 
3205 3364:                 conn.last_insert_rowid()new_tag_id
3206 3365:             }
3207 3366:         };
3208 3367: 
    ...
3930 4089:     // Add new tags
3931 4090:     for tag_name in tag_names {
3932 4091:         // Get or create tag
3933 4092:         let tag_id: i64String = match conn.query_row(
3934 4093:             "SELECT id FROM tags WHERE name = ?",
3935 4094:             params![tag_name],
3936 4095:             |row| row.get(0),
3937 4096:         ) {
3938 4097:             Ok(id) => {
3939 4098:                 // Update existing tag stats
3940 4099:                 let frequency: u32 = conn
3941 4100:                     .query_row("SELECT frequency FROM tags WHERE id = ?", params![&id], |row| row.get(0))
3942 4101:                     .unwrap_or(0);
3943 4102: 
3944 4103:                 let new_frequency = frequency + 1;
3945 4104:                 let frecency = calculate_frecency(new_frequency, &now);
3946 4105: 
3947 4106:                 conn.execute(
3948 4107:                     "UPDATE tags SET frequency = ?, lastUsed = ?, frecencyScore = ?, updatedAt = ? WHERE id = ?",
3949 4108:                     params![new_frequency, &now, frecency, &now, &id],
3950 4109:                 ).ok();
3951 4110: 
3952 4111:                 id
3953 4112:             }
3954 4113:             Err(_) => {
3955 4114:                 // Create new tag
     4115:                 let new_tag_id = generate_tag_id();
3956 4116:                 let frecency = calculate_frecency(1, &now);
3957 4117:                 conn.execute(
3958 4118:                     "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?)",
3959 4119:                     params![&new_tag_id, tag_name, &now, frecency, &now, &now],
3960 4120:                 )
3961 4121:                 .map_err(|e| format!("Failed to insert tag: {}", e))?;
3962 4122: 
3963 4123:                 conn.last_insert_rowid()new_tag_id
3964 4124:             }
3965 4125:         };
3966 4126: 
    ...
4429 4589:             CREATE INDEX IF NOT EXISTS idx_items_sync_id ON items(sync_id);
4430 4590: 
4431 4591:             CREATE TABLE IF NOT EXISTS tags (
4432 4592:                 id INTEGERTEXT PRIMARY KEY AUTOINCREMENT,
4433 4593:                 name TEXT NOT NULL UNIQUE,
4434 4594:                 frequency INTEGER NOT NULL DEFAULT 0,
4435 4595:                 lastUsed TEXT NOT NULL,
    ...
4440 4600: 
4441 4601:             CREATE TABLE IF NOT EXISTS item_tags (
4442 4602:                 item_id TEXT NOT NULL,
4443 4603:                 tag_id INTEGERTEXT NOT NULL,
4444 4604:                 created_at TEXT NOT NULL,
4445 4605:                 PRIMARY KEY (item_id, tag_id),
4446 4606:                 FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
    ...
4470 4630:                 continue;
4471 4631:             }
4472 4632: 
4473 4633:             let tag_id: i64String = match conn.query_row(
4474 4634:                 "SELECT id FROM tags WHERE name = ?",
4475 4635:                 params![&normalized],
4476 4636:                 |row| row.get(0),
4477 4637:             ) {
4478 4638:                 Ok(existing_id) => existing_id,
4479 4639:                 Err(_) => {
     4640:                     let new_tag_id = generate_tag_id();
4480 4641:                     conn.execute(
4481 4642:                         "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, 10.0, ?, ?)",
4482 4643:                         params![&new_tag_id, &normalized, &now, &now, &now],
4483 4644:                     )
4484 4645:                     .expect("Failed to insert tag");
4485 4646:                     conn.last_insert_rowid()new_tag_id
4486 4647:                 }
4487 4648:             };
4488 4649: 
    ...
4619 4780:                 continue;
4620 4781:             }
4621 4782: 
4622 4783:             let tag_id: i64String = match conn.query_row(
4623 4784:                 "SELECT id FROM tags WHERE name = ?",
4624 4785:                 params![&normalized],
4625 4786:                 |row| row.get(0),
4626 4787:             ) {
4627 4788:                 Ok(existing_id) => existing_id,
4628 4789:                 Err(_) => {
     4790:                     let new_tag_id = generate_tag_id();
4629 4791:                     conn.execute(
4630 4792:                         "INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt) VALUES (?, ?, 1, ?, 10.0, ?, ?)",
4631 4793:                         params![&new_tag_id, &normalized, &now, &now, &now],
4632 4794:                     )
4633 4795:                     .expect("Failed to insert tag");
4634 4796:                     conn.last_insert_rowid()new_tag_id
4635 4797:                 }
4636 4798:             };
4637 4799: 
    ...
Removed regular file docs/editor-remaining-work.md:
   1     : # Editor Extension - Remaining Work
   2     : 
   3     : Research note documenting what's implemented and what's missing compared to peek-edit.
   4     : 
   5     : ## Implemented Features
   6     : 
   7     : ### Folditall-Style Folding
   8     : - Header folding (all 6 levels) - folds until next same/higher level
   9     : - List item folding - nested lists with children are foldable
  10     : - Fenced code block folding (``` and ~~~)
  11     : - Vim fold commands work from any line within a fold region
  12     : 
  13     : ### Vim Fold Commands
  14     : - `za` - toggle fold
  15     : - `zc` - close/fold
  16     : - `zo` - open/unfold
  17     : - `zM` - fold all
  18     : - `zR` - unfold all
  19     : - `zm` / `zr` - simplified level-based (same as zM/zR)
  20     : - `<Space>` - toggle fold (folditall behavior)
  21     : 
  22     : ### Status Line
  23     : - Mode indicator: NORMAL (yellow), INSERT (green), VISUAL (purple)
  24     : - Cursor position: `Ln X, Col Y`
  25     : - Only visible when vim mode is enabled
  26     : 
  27     : ### Three-Panel Layout
  28     : - Outline sidebar (left) - TOC from headers
  29     : - CodeMirror editor (center)
  30     : - Preview sidebar (right) - live markdown rendering
  31     : - Resizable panels
  32     : - Focus mode (hides sidebars)
  33     : 
  34     : ## Missing Features (from peek-edit)
  35     : 
  36     : ### High Priority - Core Vim
  37     : 
  38     : | Feature | Description |
  39     : |---------|-------------|
  40     : | Text Objects | `iw`, `aw`, `is`, `as`, `ip`, `ap`, `i"`, `a"`, `i(`, `a(`, `i{`, `a{` |
  41     : | Character Search | `f`, `F`, `t`, `T`, `;`, `,` |
  42     : | Word Search | `*` (search word under cursor forward), `#` (backward) |
  43     : | Replace Mode | `R` (continuous replace until Escape) |
  44     : | Bracket Motion | `%` (jump to matching bracket) |
  45     : | Paragraph Motion | `{`, `}` (jump between paragraphs) |
  46     : | Viewport Motion | `H` (high), `M` (middle), `L` (low of viewport) |
  47     : 
  48     : **Note:** Many of these may already be in `@replit/codemirror-vim` - needs verification.
  49     : 
  50     : ### Medium Priority - Ex Commands
  51     : 
  52     : | Command | Description |
  53     : |---------|-------------|
  54     : | `:s/pat/repl/g` | Search and replace with flags |
  55     : | `:123` | Go to line 123 |
  56     : | `:noh` / `:nohlsearch` | Clear search highlighting |
  57     : | `:zen` / `:focus` | Enter focus/zen mode |
  58     : | `:outline` / `:ol` | Toggle outline sidebar |
  59     : | `:preview` / `:pv` | Toggle preview sidebar |
  60     : | `:sidebars` / `:sb` | Toggle both sidebars |
  61     : | `:narrow` / `:na` | Centered narrow layout mode |
  62     : 
  63     : ### Medium Priority - Editing Commands
  64     : 
  65     : | Command | Description |
  66     : |---------|-------------|
  67     : | `gq{motion}` | Wrap text at 78 chars, preserve indent |
  68     : | `gJ` | Join lines without space |
  69     : | `gu{motion}` | Lowercase |
  70     : | `gU{motion}` | Uppercase |
  71     : | `g~{motion}` | Toggle case |
  72     : 
  73     : ### Low Priority - Advanced
  74     : 
  75     : | Feature | Description |
  76     : |---------|-------------|
  77     : | Marks | `ma` (set mark), `'a` / `` `a `` (jump to mark) |
  78     : | Macros | `qa` (record), `q` (stop), `@a` (play), `@@` (repeat) |
  79     : | Visual Block | `<C-v>` column selection |
  80     : | Tab Completion | Tab-complete ex commands |
  81     : 
  82     : ## Implementation Notes
  83     : 
  84     : ### @replit/codemirror-vim
  85     : 
  86     : The vim plugin likely already provides many motions and text objects. Before implementing, check:
  87     : 1. What motions/text objects are already available
  88     : 2. How to add custom ex commands via `Vim.defineEx()`
  89     : 3. Whether `Vim.map()` can extend missing features
  90     : 
  91     : ### Ex Command Integration
  92     : 
  93     : To add UI control via ex commands:
  94     : ```javascript
  95     : Vim.defineEx('zen', '', (cm) => {
  96     :   // Toggle focus mode
  97     : });
  98     : 
  99     : Vim.defineEx('outline', 'ol', (cm) => {
 100     :   // Toggle outline sidebar
 101     : });
 102     : ```
 103     : 
 104     : ### Narrow Mode
 105     : 
 106     : Narrow mode centers the editor with max-width constraint. CSS approach:
 107     : ```css
 108     : .narrow-mode .editor-container {
 109     :   max-width: 720px;
 110     :   margin: 0 auto;
 111     : }
 112     : ```
 113     : 
 114     : ## Test Coverage
 115     : 
 116     : Current: 33 tests covering:
 117     : - Editor setup (3)
 118     : - Fold all/unfold all (3)
 119     : - Header folding behavior (4)
 120     : - Vim fold commands (5)
 121     : - Click-to-fold (1)
 122     : - List item folding (5)
 123     : - Code block folding (2)
 124     : - Spacebar toggle (1)
 125     : - Fold from any line (2)
 126     : - Nested behavior (2)
 127     : - Status line (5)
 128     : 
 129     : ## Files
 130     : 
 131     : - `extensions/editor/codemirror.js` - Main editor with folditall algorithm
 132     : - `extensions/editor/editor-layout.js` - Three-panel layout
 133     : - `extensions/editor/status-line.js` - Vim status bar
 134     : - `extensions/editor/outline-sidebar.js` - TOC sidebar
 135     : - `extensions/editor/preview-sidebar.js` - Markdown preview
 136     : - `tests/editor/editor-folding.spec.ts` - 33 tests
 137     : - `tests/editor/test-page.html` - Test harness
Modified regular file extensions/editor/codemirror.js:
   1    1: /**
   2    2:  * CodeMirror Editor Module
   3    3:  *
   4    4:  * Provides a configured CodeMirror instance for markdown editing
   5    5:  * with optional vim mode support and folditall-style folding.
   6    6:  */
   7    7: 
   8    8: import { EditorState, Compartment } from '@codemirror/state';
   9    9: import { EditorView, keymap, lineNumbers, highlightActiveLine, highlightActiveLineGutter, drawSelection } from '@codemirror/view';
  10   10: import { defaultKeymap, history, historyKeymap, indentWithTab } from '@codemirror/commands';
  11   11: import { markdown, markdownLanguage } from '@codemirror/lang-markdown';
  12   12: import { syntaxHighlighting, defaultHighlightStyle, bracketMatching, indentOnInput, foldGutter, foldService, codeFolding, foldAll, unfoldAll, foldEffect, unfoldEffect, foldedRanges, foldable } from '@codemirror/language';
  13   13: import { oneDark } from '@codemirror/theme-one-dark';
  14   14: import { vim, Vim, getCM } from '@replit/codemirror-vim';
  15   15: import { searchKeymap, highlightSelectionMatches } from '@codemirror/search';
  16   16: 
  17   17: // Compartments for runtime-reconfigurable extensions
  18   18: const vimCompartment = new Compartment();
  19   19: const themeCompartment = new Compartment();
  20   20: 
  21     : // ============================================================================
  22     : // Folditall Algorithm Helpers
  23     : // ============================================================================
  24     : 
  25     : /**
  26     :  * Get the header level (1-6) from a line, or 0 if not a header.
  27     :  */
  28     : function getHeaderLevel(text) {
  29     :   const match = text.match(/^(#{1,6})\s+/);
  30     :   return match ? match[1].length : 0;
  31     : }
  32     : 
  33     : /**
  34     :  * Check if a line is a list item (bullet or numbered).
  35     :  */
  36     : function isListItem(text) {
  37     :   return /^\s*[-*+]\s/.test(text) || /^\s*\d+[.)]\s/.test(text);
  38     : }
  39     : 
  40     : /**
  41     :  * Get the indentation level of a line (number of leading spaces/tabs).
  42     :  * Tabs count as 2 spaces.
  43     :  */
  44     : function getIndent(text) {
  45     :   let indent = 0;
  46     :   for (const char of text) {
  47     :     if (char === ' ') indent++;
  48     :     else if (char === '\t') indent += 2;
  49     :     else break;
  50     :   }
  51     :   return indent;
  52     : }
  53     : 
  54     : /**
  55     :  * Check if a line is blank or whitespace-only.
  56     :  */
  57     : function isBlankLine(text) {
  58     :   return /^\s*$/.test(text);
  59     : }
  60     : 
  61     : /**
  62     :  * Check if a line is a fenced code block opener (``` or ~~~).
  63     :  */
  64     : function isFencedCodeBlockOpener(text) {
  65     :   return /^(`{3,}|~{3,})/.test(text.trim());
  66     : }
  67     : 
  68     : /**
  69     :  * Find the closing fence for a fenced code block.
  70     :  * Returns line number of closing fence, or null if not found.
  71     :  */
  72     : function findClosingFence(doc, openerLineNum) {
  73     :   const openerLine = doc.line(openerLineNum);
  74     :   const openerText = openerLine.text.trim();
  75     :   const match = openerText.match(/^(`{3,}|~{3,})/);
  76     :   if (!match) return null;
  77     : 
  78     :   const fenceChar = match[1][0];
  79     :   const fenceLen = match[1].length;
  80     :   const totalLines = doc.lines;
  81     : 
  82     :   for (let i = openerLineNum + 1; i <= totalLines; i++) {
  83     :     const line = doc.line(i);
  84     :     const trimmed = line.text.trim();
  85     :     // Closing fence must be same char and at least same length
  86     :     const closeMatch = trimmed.match(new RegExp(`^${fenceChar}{${fenceLen},}$`));
  87     :     if (closeMatch) {
  88     :       return i;
  89     :     }
  90     :   }
  91     :   return null;
  92     : }
  93     : 
  94     : /**
  95     :  * Find the next non-blank line number after lineNum.
  96     :  * Returns null if no non-blank line exists.
  97     :  */
  98     : function findNextNonBlank(doc, lineNum) {
  99     :   const totalLines = doc.lines;
 100     :   for (let i = lineNum + 1; i <= totalLines; i++) {
 101     :     const line = doc.line(i);
 102     :     if (!isBlankLine(line.text)) {
 103     :       return i;
 104     :     }
 105     :   }
 106     :   return null;
 107     : }
 108     : 
 109     : /**
 110     :  * Check if a line can start a fold based on folditall rules:
 111     :  * - Headers always can start folds
 112     :  * - List items can start folds (if they have children)
 113     :  * - Fenced code block openers can start folds
 114     :  * - Indent-0 lines can start folds (if they have indented children)
 115     :  */
 116     : function canStartFold(text) {
 117     :   if (getHeaderLevel(text) > 0) return true;
 118     :   if (isListItem(text)) return true;
 119     :   if (isFencedCodeBlockOpener(text)) return true;
 120     :   if (getIndent(text) === 0 && !isBlankLine(text)) return true;
 121     :   return false;
 122     : }
 123     : 
 124     : /**
 125     :  * Check if a line has foldable children (more-indented content following it).
 126     :  */
 127     : function hasFoldableChildren(doc, lineNum) {
 128     :   const line = doc.line(lineNum);
 129     :   const text = line.text;
 130     : 
 131     :   // Headers always have children (until next same/higher level header)
 132     :   if (getHeaderLevel(text) > 0) return true;
 133     : 
 134     :   // Fenced code blocks have children if there's a closing fence
 135     :   if (isFencedCodeBlockOpener(text)) {
 136     :     return findClosingFence(doc, lineNum) !== null;
 137     :   }
 138     : 
 139     :   const currentIndent = getIndent(text);
 140     :   const nextNonBlankNum = findNextNonBlank(doc, lineNum);
 141     : 
 142     :   if (nextNonBlankNum === null) return false;
 143     : 
 144     :   const nextLine = doc.line(nextNonBlankNum);
 145     :   const nextText = nextLine.text;
 146     : 
 147     :   // Next line must be more indented (and not a header)
 148     :   if (getHeaderLevel(nextText) > 0) return false;
 149     : 
 150     :   return getIndent(nextText) > currentIndent;
 151     : }
 152     : 
 153     : /**
 154     :  * Find the end of a fold region starting at lineNum.
 155     :  * For headers: ends at next header of same or higher level.
 156     :  * For fenced code blocks: ends at the closing fence.
 157     :  * For list/indent: ends when indentation returns to same or lower level.
 158     :  */
 159     : function findFoldEnd(doc, lineNum) {
 160     :   const line = doc.line(lineNum);
 161     :   const text = line.text;
 162     :   const totalLines = doc.lines;
 163     :   const headerLevel = getHeaderLevel(text);
 164     : 
 165     :   if (headerLevel > 0) {
 166     :     // Header fold: ends at next header of same or higher level
 167     :     for (let i = lineNum + 1; i <= totalLines; i++) {
 168     :       const checkLine = doc.line(i);
 169     :       const checkLevel = getHeaderLevel(checkLine.text);
 170     :       if (checkLevel > 0 && checkLevel <= headerLevel) {
 171     :         return i - 1;
 172     :       }
 173     :     }
 174     :     return totalLines;
 175     :   }
 176     : 
 177     :   // Fenced code block fold: ends at closing fence
 178     :   if (isFencedCodeBlockOpener(text)) {
 179     :     const closingLine = findClosingFence(doc, lineNum);
 180     :     return closingLine !== null ? closingLine : lineNum;
 181     :   }
 182     : 
 183     :   // List/indent fold: ends when indentation returns to same or lower level
 184     :   const startIndent = getIndent(text);
 185     :   let lastContentLine = lineNum;
 186     : 
 187     :   for (let i = lineNum + 1; i <= totalLines; i++) {
 188     :     const checkLine = doc.line(i);
 189     :     const checkText = checkLine.text;
 190     : 
 191     :     // Skip blank lines but track last content
 192     :     if (isBlankLine(checkText)) continue;
 193     : 
 194     :     // Headers break indent folds
 195     :     if (getHeaderLevel(checkText) > 0) {
 196     :       return lastContentLine;
 197     :     }
 198     : 
 199     :     const checkIndent = getIndent(checkText);
 200     : 
 201     :     // If indent is same or less, fold ends at previous content line
 202     :     if (checkIndent <= startIndent) {
 203     :       return lastContentLine;
 204     :     }
 205     : 
 206     :     lastContentLine = i;
 207     :   }
 208     : 
 209     :   return lastContentLine;
 210     : }
 211     : 
 212     : /**
 213     :  * Folditall-style folding: find the fold region containing a line.
 214     :  * Searches backwards to find the nearest fold-starting line that contains this line.
 215     :  */
 216     : function findContainingFoldStart(state, lineNum) {
 217     :   const doc = state.doc;
 218     :   const currentLine = doc.line(lineNum);
 219     :   const currentText = currentLine.text;
 220     : 
 221     :   // If current line can start a fold and has children, return it
 222     :   if (canStartFold(currentText) && hasFoldableChildren(doc, lineNum)) {
 223     :     return currentLine.from;
 224     :   }
 225     : 
 226     :   const currentIndent = getIndent(currentText);
 227     : 
 228     :   // Search backwards for a containing fold region
 229     :   for (let i = lineNum - 1; i >= 1; i--) {
 230     :     const line = doc.line(i);
 231     :     const text = line.text;
 232     : 
 233     :     // Skip blank lines
 234     :     if (isBlankLine(text)) continue;
 235     : 
 236     :     const lineIndent = getIndent(text);
 237     :     const headerLevel = getHeaderLevel(text);
 238     : 
 239     :     // Headers always contain following content (until next same-level header)
 240     :     if (headerLevel > 0) {
 241     :       // Check if this header's fold extends to our line
 242     :       const foldEnd = findFoldEnd(doc, i);
 243     :       if (foldEnd >= lineNum) {
 244     :         return line.from;
 245     :       }
 246     :       continue;
 247     :     }
 248     : 
 249     :     // List items or indent-0 lines with less indent could contain us
 250     :     if (lineIndent < currentIndent && canStartFold(text) && hasFoldableChildren(doc, i)) {
 251     :       const foldEnd = findFoldEnd(doc, i);
 252     :       if (foldEnd >= lineNum) {
 253     :         return line.from;
 254     :       }
 255     :     }
 256     :   }
 257     : 
 258     :   return null;
 259     : }
 260     : 
 261     : /**
 262     :  * Check if a position is inside a folded range.
 263     :  */
 264     : function isPositionFolded(state, pos) {
 265     :   const folded = foldedRanges(state);
 266     :   let found = false;
 267     :   folded.between(0, state.doc.length, (from, to) => {
 268     :     if (pos >= from && pos <= to) {
 269     :       found = true;
 270     :     }
 271     :   });
 272     :   return found;
 273     : }
 274     : 
 275     : /**
 276     :  * Find the fold range at a position (if folded).
 277     :  */
 278     : function findFoldedRangeAt(state, pos) {
 279     :   const folded = foldedRanges(state);
 280     :   let result = null;
 281     :   folded.between(0, state.doc.length, (from, to) => {
 282     :     if (pos >= from && pos <= to) {
 283     :       result = { from, to };
 284     :     }
 285     :   });
 286     :   return result;
 287     : }
 288     : 
 289     : // Define vim fold commands using folditall-style region finding
 290     : Vim.defineAction('foldAll', (cm) => {
 291     :   foldAll(cm.cm6);
 292     : });
 293     : 
 294     : Vim.defineAction('unfoldAll', (cm) => {
 295     :   unfoldAll(cm.cm6);
 296     : });
 297     : 
 298     : Vim.defineAction('foldCode', (cm) => {
 299     :   const view = cm.cm6;
 300     :   const pos = view.state.selection.main.head;
 301     :   const lineNum = view.state.doc.lineAt(pos).number;
 302     : 
 303     :   // Find the containing fold region's start
 304     :   const foldStart = findContainingFoldStart(view.state, lineNum);
 305     :   if (foldStart !== null) {
 306     :     // Get the foldable range at the fold start
 307     :     const foldRange = foldable(view.state, foldStart, foldStart);
 308     :     if (foldRange) {
 309     :       // Create fold effect
 310     :       view.dispatch({
 311     :         effects: foldEffect.of({ from: foldRange.from, to: foldRange.to })
 312     :       });
 313     :     }
 314     :   }
 315     : });
 316     : 
 317     : Vim.defineAction('unfoldCode', (cm) => {
 318     :   const view = cm.cm6;
 319     :   const pos = view.state.selection.main.head;
 320     :   const line = view.state.doc.lineAt(pos);
 321     :   const lineNum = line.number;
 322     : 
 323     :   // First check if we're in a folded range (cursor inside fold)
 324     :   const foldedRange = findFoldedRangeAt(view.state, pos);
 325     :   if (foldedRange) {
 326     :     view.dispatch({
 327     :       effects: unfoldEffect.of({ from: foldedRange.from, to: foldedRange.to })
 328     :     });
 329     :     return;
 330     :   }
 331     : 
 332     :   // Check if there's a fold starting at the end of current line (we're on the fold line)
 333     :   const foldAtLineEnd = findFoldedRangeAt(view.state, line.to);
 334     :   if (foldAtLineEnd) {
 335     :     view.dispatch({
 336     :       effects: unfoldEffect.of({ from: foldAtLineEnd.from, to: foldAtLineEnd.to })
 337     :     });
 338     :     return;
 339     :   }
 340     : 
 341     :   // Find the containing fold region and try to unfold it
 342     :   const foldStart = findContainingFoldStart(view.state, lineNum);
 343     :   if (foldStart !== null) {
 344     :     const foldStartLine = view.state.doc.lineAt(foldStart);
 345     :     const foldRange = foldable(view.state, foldStartLine.from, foldStartLine.to);
 346     :     if (foldRange) {
 347     :       // Check if this range is folded
 348     :       const folded = foldedRanges(view.state);
 349     :       let isFolded = false;
 350     :       folded.between(foldRange.from, foldRange.to, (from, to) => {
 351     :         if (from === foldRange.from) {
 352     :           isFolded = true;
 353     :         }
 354     :       });
 355     :       if (isFolded) {
 356     :         view.dispatch({
 357     :           effects: unfoldEffect.of({ from: foldRange.from, to: foldRange.to })
 358     :         });
 359     :       }
 360     :     }
 361     :   }
 362     : });
 363     : 
 364     : Vim.defineAction('toggleFold', (cm) => {
 365     :   const view = cm.cm6;
 366     :   const pos = view.state.selection.main.head;
 367     :   const lineNum = view.state.doc.lineAt(pos).number;
 368     : 
 369     :   // Find the containing fold region's start
 370     :   const foldStart = findContainingFoldStart(view.state, lineNum);
 371     :   if (foldStart === null) return;
 372     : 
 373     :   const line = view.state.doc.lineAt(foldStart);
 374     :   const foldRange = foldable(view.state, line.from, line.to);
 375     :   if (!foldRange) return;
 376     : 
 377     :   // Check if this range is currently folded
 378     :   const folded = foldedRanges(view.state);
 379     :   let isFolded = false;
 380     :   folded.between(foldRange.from, foldRange.to, (from, to) => {
 381     :     if (from === foldRange.from) {
 382     :       isFolded = true;
 383     :     }
 384     :   });
 385     : 
 386     :   if (isFolded) {
 387     :     view.dispatch({
 388     :       effects: unfoldEffect.of({ from: foldRange.from, to: foldRange.to })
 389     :     });
 390     :   } else {
 391     :     view.dispatch({
 392     :       effects: foldEffect.of({ from: foldRange.from, to: foldRange.to })
 393     :     });
 394     :   }
 395     : });
 396     : 
 397     : // Map vim fold commands
 398     : Vim.mapCommand('zc', 'action', 'foldCode', {}, { context: 'normal' });
 399     : Vim.mapCommand('zo', 'action', 'unfoldCode', {}, { context: 'normal' });
 400     : Vim.mapCommand('za', 'action', 'toggleFold', {}, { context: 'normal' });
 401     : Vim.mapCommand('zM', 'action', 'foldAll', {}, { context: 'normal' });
 402     : Vim.mapCommand('zR', 'action', 'unfoldAll', {}, { context: 'normal' });
 403     : // zr and zm are level-based - simplified to same as zR/zM for now
 404     : Vim.mapCommand('zr', 'action', 'unfoldAll', {}, { context: 'normal' });
 405     : Vim.mapCommand('zm', 'action', 'foldAll', {}, { context: 'normal' });
 406     : // Space toggles fold (like za) - folditall behavior
 407     : Vim.mapCommand('<Space>', 'action', 'toggleFold', {}, { context: 'normal' });
 408     : 
 409   21: /**
 410   22:  * Create a peek-themed CodeMirror theme using CSS variables
 411   23:  */
    ...
 515  127: }, { dark: true });
 516  128: 
 517  129: /**
 518     :  * Folditall-style fold service.
 519     :  * Handles:
 520     :  * - Markdown headers (fold to next same/higher level header)
 521     :  * - List items with children (fold nested content)
 522     :  * - Indent-0 lines with indented children (code blocks, etc.)
 523     :  */
 524     : const folditallFoldService = foldService.of((state, lineStart, lineEnd) => {
 525     :   const doc = state.doc;
 526     :   const line = doc.lineAt(lineStart);
 527     :   const text = line.text;
 528     :   const lineNum = line.number;
 529     : 
 530     :   // Skip blank lines
 531     :   if (isBlankLine(text)) return null;
 532     : 
 533     :   // Check if this line can start a fold and has children
 534     :   if (!canStartFold(text)) return null;
 535     :   if (!hasFoldableChildren(doc, lineNum)) return null;
 536     : 
 537     :   // Find fold end
 538     :   const endLineNum = findFoldEnd(doc, lineNum);
 539     : 
 540     :   // Don't fold if there's nothing to fold
 541     :   if (endLineNum <= lineNum) return null;
 542     : 
 543     :   const endLine = doc.line(endLineNum);
 544     : 
 545     :   // Fold from end of starting line to end of last line in section
 546     :   return { from: line.to, to: endLine.to };
 547     : });
 548     : 
 549     : /**
 550  130:  * Create a CodeMirror editor instance
 551  131:  * @param {Object} options - Configuration options
 552  132:  * @param {HTMLElement} options.parent - Parent element to mount editor in
 553  133:  * @param {string} options.content - Initial content
 554  134:  * @param {boolean} options.vimMode - Enable vim mode
 555  135:  * @param {boolean} options.showLineNumbers - Show line numbers
 556  136:  * @param {Function} options.onChange - Callback when content changes
 557     :  * @param {Function} options.onSelectionChange - Callback when cursor position changes (line, col)
 558     :  * @param {Function} options.onVimModeChange - Callback when vim mode changes (mode string)
 559  137:  * @returns {EditorView} - CodeMirror EditorView instance
 560  138:  */
 561  139: export function createEditor({ parent, content = '', vimMode = false, showLineNumbers = true, onChange, onSelectionChange, onVimModeChange }) {
 562     :   // Track last known vim mode to detect changes
 563     :   let lastVimMode = 'normal';
 564     : 
 565  140:   const extensions = [
 566  141:     // Core extensions
 567  142:     history(),
    ...
 584  159:     markdown({ base: markdownLanguage }),
 585  160:     syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
 586  161: 
 587     :     // Folding support (required for vim fold commands)
 588     :     codeFolding(),
 589     :     folditallFoldService,
 590     : 
 591  162:     // Theming
 592  163:     themeCompartment.of(peekTheme),
 593  164: 
 594  165:     // Vim mode (initially based on setting)
 595  166:     vimCompartment.of(vimMode ? vim() : []),
 596  167: 
 597  168:     // UpdateChange listener for content, selection, and vim mode changes
 598  169:     EditorView.updateListener.of(update => {
 599     :       // Content change
 600  170:       if (update.docChanged && onChange) {
 601  171:         onChange(update.state.doc.toString());
 602  172:       }
 603     : 
 604     :       // Selection/cursor change
 605     :       if (update.selectionSet && onSelectionChange) {
 606     :         const pos = update.state.selection.main.head;
 607     :         const line = update.state.doc.lineAt(pos);
 608     :         const col = pos - line.from + 1;
 609     :         onSelectionChange(line.number, col);
 610     :       }
 611     : 
 612     :       // Vim mode change detection
 613     :       if (onVimModeChange && vimMode) {
 614     :         try {
 615     :           const cm = getCM(update.view);
 616     :           if (cm && cm.state && cm.state.vim) {
 617     :             const vimState = cm.state.vim;
 618     :             let currentMode = 'normal';
 619     : 
 620     :             if (vimState.insertMode) {
 621     :               currentMode = 'insert';
 622     :             } else if (vimState.visualMode) {
 623     :               currentMode = vimState.visualLine ? 'visual-line' :
 624     :                            vimState.visualBlock ? 'visual-block' : 'visual';
 625     :             } else if (vimState.mode === 'replace') {
 626     :               currentMode = 'replace';
 627     :             }
 628     : 
 629     :             if (currentMode !== lastVimMode) {
 630     :               lastVimMode = currentMode;
 631     :               onVimModeChange(currentMode);
 632     :             }
 633     :           }
 634     :         } catch (e) {
 635     :           // Vim not active
 636     :         }
 637     :       }
 638  173:     }),
 639  174:   ];
 640  175: 
    ...
 653  188:     parent,
 654  189:   });
 655  190: 
 656     :   // Initial position callback
 657     :   if (onSelectionChange) {
 658     :     const pos = view.state.selection.main.head;
 659     :     const line = view.state.doc.lineAt(pos);
 660     :     const col = pos - line.from + 1;
 661     :     onSelectionChange(line.number, col);
 662     :   }
 663     : 
 664     :   // Initial vim mode callback
 665     :   if (onVimModeChange && vimMode) {
 666     :     onVimModeChange('normal');
 667     :   }
 668     : 
 669  191:   return view;
 670  192: }
 671  193: 
    ...
Modified regular file extensions/editor/editor-layout.js:
    ...
   6    6: 
   7    7: import { OutlineSidebar } from './outline-sidebar.js';
   8    8: import { PreviewSidebar } from './preview-sidebar.js';
   9     : import { StatusLine } from './status-line.js';
  10    9: import * as CodeMirror from './codemirror.js';
  11   10: 
  12   11: export class EditorLayout {
  13   12:   constructor(options) {
  14   13:     this.container = options.container;
  15   14:     this.onContentChange = options.onContentChange;
  16     :     this.onVimModeChange = options.onVimModeChange;
  17   15:     this.initialContent = options.initialContent || '';
  18   16:     this.vimMode = options.vimMode || false;
  19   17: 
  20   18:     this.outlineSidebar = null;
  21   19:     this.previewSidebar = null;
  22     :     this.statusLine = null;
  23   20:     this.cmEditor = null;
  24   21:     this.lastContent = '';
  25   22:     this.rafId = null;
    ...
  54   51:     this.cmContainer.className = 'cm-container';
  55   52:     this.editorContainer.appendChild(this.cmContainer);
  56   53: 
  57     :     // Status line container (below editor, above toolbar)
  58     :     this.statusLineContainer = document.createElement('div');
  59     :     this.statusLineContainer.className = 'status-line-container';
  60     :     this.editorContainer.appendChild(this.statusLineContainer);
  61     : 
  62   54:     // Toolbar below editor
  63   55:     this.toolbar = document.createElement('div');
  64   56:     this.toolbar.className = 'editor-toolbar';
  65   57: 
       58:     // Vim mode toggle
       59:     this.vimToggle = document.createElement('label');
       60:     this.vimToggle.className = 'vim-toggle';
       61: 
       62:     this.vimCheckbox = document.createElement('input');
       63:     this.vimCheckbox.type = 'checkbox';
       64:     this.vimCheckbox.checked = this.vimMode;
       65:     this.vimCheckbox.addEventListener('change', () => this.handleVimToggle());
       66: 
       67:     const vimLabel = document.createElement('span');
       68:     vimLabel.textContent = 'Vim';
       69: 
       70:     this.vimToggle.appendChild(this.vimCheckbox);
       71:     this.vimToggle.appendChild(vimLabel);
       72:     this.toolbar.appendChild(this.vimToggle);
       73: 
  66   74:     // Sidebar toggles
  67   75:     const sidebarToggles = document.createElement('div');
  68   76:     sidebarToggles.className = 'sidebar-toggles';
    ...
 104  112: 
 105  113:     this.container.appendChild(this.wrapper);
 106  114: 
 107     :     // Initialize status line (only shown when vim mode is enabled)
 108     :     this.statusLine = new StatusLine({
 109     :       container: this.statusLineContainer,
 110     :     });
 111     : 
 112     :     // Hide status line initially if vim mode is off
 113     :     if (!this.vimMode) {
 114     :       this.statusLine.hide();
 115     :     }
 116     : 
 117  115:     // Initialize CodeMirror
 118  116:     this.cmEditor = CodeMirror.createEditor({
 119  117:       parent: this.cmContainer,
 120  118:       content: this.initialContent,
 121  119:       vimMode: this.vimMode,
 122  120:       showLineNumbers: true,
 123  121:       onChange: (content) => this.handleContentChange(content),
 124     :       onSelectionChange: (line, col) => this.handleSelectionChange(line, col),
 125     :       onVimModeChange: (mode) => this.handleVimModeUpdate(mode),
 126  122:     });
 127  123: 
 128  124:     // Default sidebars to collapsed
    ...
 274  270:     }
 275  271:   }
 276  272: 
 277  273:   /**
 278     :    * Update vim mode state (called from setVimMode).
 279     :    */
 280  273:   updateVimModeStatehandleVimToggle(enabled) {
 281  274:     this.vimMode = enabledthis.vimCheckbox.checked;
 282  275:     if (this.cmEditor) {
 283  276:       CodeMirror.setVimMode(this.cmEditor, this.vimMode);
 284  277:     }
 285     : 
 286     :     // Show/hide status line based on vim mode
 287     :     if (this.statusLine) {
 288     :       if (this.vimMode) {
 289     :         this.statusLine.show();
 290     :         this.statusLine.updateMode('normal');
 291     :       } else {
 292     :         this.statusLine.hide();
 293     :       }
 294     :     }
 295     : 
 296     :     // Notify parent of vim mode change for persistence
 297     :     if (this.onVimModeChange) {
 298     :       this.onVimModeChange(this.vimMode);
 299     :     }
 300     :   }
 301     : 
 302     :   /**
 303     :    * Handle cursor position changes.
 304     :    */
 305     :   handleSelectionChange(line, col) {
 306     :     if (this.statusLine) {
 307     :       this.statusLine.updatePosition(line, col);
 308     :     }
 309     :   }
 310     : 
 311     :   /**
 312     :    * Handle vim mode state changes (normal, insert, visual, etc.)
 313     :    */
 314     :   handleVimModeUpdate(mode) {
 315     :     if (this.statusLine && this.vimMode) {
 316     :       this.statusLine.updateMode(mode);
 317     :     }
 318  278:   }
 319  279: 
 320  280:   jumpToHeader(header) {
    ...
 448  408:    * Set vim mode.
 449  409:    */
 450  410:   setVimMode(enabled) {
 451  411:     this.updateVimModeState(vimMode = enabled;
      412:     this.vimCheckbox.checked = enabled;
      413:     if (this.cmEditor) {
 451  414:       CodeMirror.setVimMode(this.cmEditor, enabled);
      415:     }
 452  416:   }
 453  417: 
 454  418:   /**
    ...
 483  447:       this.cmEditor = null;
 484  448:     }
 485  449: 
 486     :     this.statusLine?.destroy();
 487  450:     this.outlineSidebar?.destroy();
 488  451:     this.previewSidebar?.destroy();
 489  452:     this.wrapper.remove();
    ...
Modified regular file extensions/editor/home.js:
    ...
  17   17: // Editor layout instance
  18   18: let editorLayout = null;
  19   19: 
  20   20: // Settings keystore for vim mode preference
       21: let settingsStore = null;
  21   22: const SETTINGS_KEY = 'editor.vimMode';
  22   23: 
  23   24: /**
  24     :  * Sample markdown content for testing folding features.
  25     :  * Tests: headers (6 levels), nested lists, code blocks.
       25:  * Sample markdown content for new documents
  26   26:  */
  27     : const SAMPLE_CONTENT = `# Level 1 Header - Main Document
  28     : 
  29     : This content is under a level 1 header.
  30     : 
  31     : ## Level 2 - Features
  32     : 
  33     : Content under level 2.
  34     : 
  35     : ### Level 3 - Folding Types
  36     : 
  37     : We support multiple folding types.
  38     : 
  39     : #### Level 4 - Header Folding
  40     : 
  41     : Headers fold everything until the next header of same or higher level.
  42     : 
  43     : ##### Level 5 - Deep Nesting
  44     : 
  45     : This is deeply nested content.
  46     : 
  47     : ###### Level 6 - Maximum Depth
  48     : 
  49     : This is the deepest header level supported.
  50     : 
  51     : Back to level 5 content.
  52     : 
  53     : ##### Level 5 - Another Section
  54     : 
  55     : Another level 5 section.
  56     : 
  57     : #### Level 4 - List Folding
  58     : 
  59     : Lists with children are foldable:
  60     : 
  61     : - Parent item with children
  62     :   - Child item one
  63     :   - Child item two
  64     :     - Grandchild item
  65     :     - Another grandchild
  66     :   - Child item three
  67     : - Simple item (no children)
  68     : - Another parent
  69     :   - Single child
  70     : 
  71     : Numbered lists also fold:
  72     : 
  73     : 1. First parent
  74     :    1. Sub-item one
  75     :    2. Sub-item two
  76     : 2. Second parent
  77     :    - Mixed child
  78     :    - Another mixed
  79     : 
  80     : #### Level 4 - Code Block Folding
  81     : 
  82     : Top-level code blocks fold their contents:
       27: const SAMPLE_CONTENT = `# Welcome to the Editor
       28: 
       29: This is a **markdown editor** with live preview and outline navigation.
       30: 
       31: ## Features
       32: 
       33: - **Outline sidebar** - Click headers to jump to them
       34: - **Live preview** - See rendered markdown as you type
       35: - **Vim mode** - Toggle vim keybindings in the toolbar
       36: - **Focus mode** - Distraction-free editing
       37: 
       38: ## Getting Started
       39: 
       40: Start typing to edit this document. Use the toolbar buttons to toggle sidebars.
       41: 
       42: ### Keyboard Shortcuts
       43: 
       44: - \`Cmd+Shift+O\` - Toggle outline sidebar
       45: - \`Cmd+Shift+P\` - Toggle preview sidebar
       46: - \`Escape\` - Exit focus mode
       47: 
       48: ## Code Example
  83   49: 
  84   50: \`\`\`javascript
  85   51: function examplegreet(name) {
  86   52:   return  if (condition) {
  87     :         doSomething();
  88     :     }
  89     :     return result;
  90     : }
  91     : 
  92     : class MyClass {
  93     :     constructor() {
  94     :         this.x = 1;
  95     :     }
  96     : 
  97     :     method() {
  98     :         return this.x;
  99   52:     }\`Hello, \${name}!\`;
 100   53: }
 101   54: \`\`\`
 102   55: 
 103     : ### Level 3 - Vim Fold Commands
 104     : 
 105     : Test these vim commands (enable vim mode first):
 106     : 
 107     : | Command | Action |
 108     : |---------|--------|
 109     : | \`za\` | Toggle fold under cursor |
 110     : | \`zo\` | Open fold under cursor |
 111     : | \`zc\` | Close fold under cursor |
 112     : | \`zR\` | Open all folds |
 113     : | \`zM\` | Close all folds |
 114     : | \`zr\` | Reduce folding (open one level) |
 115     : | \`zm\` | More folding (close one level) |
 116     : 
 117     : ## Level 2 - Another Top Section
 118     : 
 119     : This tests that level 2 properly ends the previous level 2 section.
 120     : 
 121     : ### Level 3 - Final Nested
 122     : 
 123     : Final nested content.
 124     : 
 125     : ## Level 2 - Conclusion
 126     : 
 127     : End of test document.
       56: ## Lists
       57: 
       58: - Item one
       59: - Item two
       60: - Item three
       61: 
       62: 1. First
       63: 2. Second
       64: 3. Third
       65: 
       66: ## Links and Images
       67: 
       68: [Visit GitHub](https://github.com)
       69: 
       70: > This is a blockquote.
       71: > It can span multiple lines.
       72: 
       73: ---
       74: 
       75: *Happy writing!*
 128   76: `;
 129   77: 
 130   78: /**
    ...
 139   87:     return;
 140   88:   }
 141   89: 
 142   90:   // Load vim mode preference from localStorage
 143   91:   let vimMode = false;
 144     :   try {
 145     :     vimMode = localStorage.getItem(SETTINGS_KEY) === 'true';
 146     :     debug && console.log('[editor] Loaded vimMode setting:', vimMode);
 147     :   } catch (err) {
 148     :     debug && console.log('[editor] Failed to load settings:', err);
       92:   if (api?.utils?.createDatastoreStore) {
       93:     try {
       94:       settingsStore = await api.utils.createDatastoreStore('editor', { vimMode: false });
       95:       vimMode = settingsStore.get(SETTINGS_KEY) || false;
       96:       debug && console.log('[editor] Loaded vimMode setting:', vimMode);
       97:     } catch (err) {
       98:       debug && console.log('[editor] Failed to load settings:', err);
       99:     }
 149  100:   }
 150  101: 
 151  102:   // Check URL params for content or file path
    ...
 178  129:     initialContent,
 179  130:     vimMode,
 180  131:     onContentChange: handleContentChange,
 181     :     onVimModeChange: handleVimModeChange,
 182  132:   });
 183  133: 
 184  134:   // Set up escape handler
    ...
 192  142:     });
 193  143:   }
 194  144: 
      145:   // Listen for vim mode changes to persist
      146:   const vimCheckbox = document.querySelector('.vim-toggle input');
      147:   if (vimCheckbox) {
      148:     vimCheckbox.addEventListener('change', async () => {
      149:       const enabled = vimCheckbox.checked;
      150:       if (settingsStore) {
      151:         try {
      152:           await settingsStore.set(SETTINGS_KEY, enabled);
      153:           debug && console.log('[editor] Saved vimMode setting:', enabled);
      154:         } catch (err) {
      155:           debug && console.log('[editor] Failed to save vimMode setting:', err);
      156:         }
      157:       }
      158:     });
      159:   }
      160: 
 195  161:   debug && console.log('[editor] Editor initialized');
 196  162: };
 197  163: 
    ...
 206  172: };
 207  173: 
 208  174: /**
 209     :  * Handle vim mode changes - persist to localStorage
 210     :  */
 211     : const handleVimModeChange = (enabled) => {
 212     :   try {
 213     :     localStorage.setItem(SETTINGS_KEY, enabled ? 'true' : 'false');
 214     :     console.log('[editor] Saved vimMode setting:', enabled);
 215     :   } catch (err) {
 216     :     console.error('[editor] Failed to save vimMode setting:', err);
 217     :   }
 218     : };
 219     : 
 220     : /**
 221  175:  * Clean up on unload
 222  176:  */
 223  177: const cleanup = () => {
    ...
Removed regular file extensions/editor/status-line.js:
   1     : /**
   2     :  * Status Line - Vim-style status bar for CodeMirror editor.
   3     :  *
   4     :  * Displays:
   5     :  * - Mode indicator (NORMAL, INSERT, VISUAL, V-LINE)
   6     :  * - Cursor position (Ln X, Col Y)
   7     :  * - Temporary messages
   8     :  */
   9     : 
  10     : export class StatusLine {
  11     :   constructor(options = {}) {
  12     :     this.container = options.container;
  13     :     this.currentMode = 'normal';
  14     :     this.messageTimeout = null;
  15     :     this.originalModeText = '';
  16     : 
  17     :     this.init();
  18     :   }
  19     : 
  20     :   init() {
  21     :     // Create status line container
  22     :     this.element = document.createElement('div');
  23     :     this.element.className = 'vim-status-line';
  24     :     this.element.style.cssText = `
  25     :       display: flex;
  26     :       justify-content: space-between;
  27     :       align-items: center;
  28     :       padding: 4px 12px;
  29     :       background: var(--base00);
  30     :       border-top: 1px solid var(--base02);
  31     :       min-height: 22px;
  32     :       font-family: var(--theme-font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace);
  33     :       font-size: 12px;
  34     :     `;
  35     : 
  36     :     // Mode indicator (left side)
  37     :     this.modeIndicator = document.createElement('span');
  38     :     this.modeIndicator.className = 'vim-mode-indicator';
  39     :     this.modeIndicator.style.cssText = `
  40     :       color: var(--base0A);
  41     :       font-weight: 600;
  42     :     `;
  43     :     this.modeIndicator.textContent = 'NORMAL';
  44     : 
  45     :     // Position info (right side)
  46     :     this.positionInfo = document.createElement('span');
  47     :     this.positionInfo.className = 'vim-position-info';
  48     :     this.positionInfo.style.cssText = `
  49     :       color: var(--base04);
  50     :     `;
  51     :     this.positionInfo.textContent = 'Ln 1, Col 1';
  52     : 
  53     :     this.element.appendChild(this.modeIndicator);
  54     :     this.element.appendChild(this.positionInfo);
  55     : 
  56     :     if (this.container) {
  57     :       this.container.appendChild(this.element);
  58     :     }
  59     :   }
  60     : 
  61     :   /**
  62     :    * Update the mode display.
  63     :    * @param {string} mode - The vim mode ('normal', 'insert', 'visual', 'visual-line', 'replace')
  64     :    */
  65     :   updateMode(mode) {
  66     :     this.currentMode = mode;
  67     : 
  68     :     const modeLabels = {
  69     :       'normal': 'NORMAL',
  70     :       'insert': '-- INSERT --',
  71     :       'visual': '-- VISUAL --',
  72     :       'visual-line': '-- V-LINE --',
  73     :       'visual-block': '-- V-BLOCK --',
  74     :       'replace': '-- REPLACE --',
  75     :     };
  76     : 
  77     :     const modeColors = {
  78     :       'normal': 'var(--base0A)',      // Yellow
  79     :       'insert': 'var(--base0B)',      // Green
  80     :       'visual': 'var(--base0E)',      // Purple
  81     :       'visual-line': 'var(--base0E)', // Purple
  82     :       'visual-block': 'var(--base0E)', // Purple
  83     :       'replace': 'var(--base08)',     // Red
  84     :     };
  85     : 
  86     :     const label = modeLabels[mode] || mode.toUpperCase();
  87     :     const color = modeColors[mode] || 'var(--base05)';
  88     : 
  89     :     this.modeIndicator.textContent = label;
  90     :     this.modeIndicator.style.color = color;
  91     :     this.originalModeText = label;
  92     :   }
  93     : 
  94     :   /**
  95     :    * Update the cursor position display.
  96     :    * @param {number} line - Current line number (1-indexed)
  97     :    * @param {number} col - Current column number (1-indexed)
  98     :    */
  99     :   updatePosition(line, col) {
 100     :     this.positionInfo.textContent = `Ln ${line}, Col ${col}`;
 101     :   }
 102     : 
 103     :   /**
 104     :    * Show a temporary message in place of the mode indicator.
 105     :    * @param {string} message - Message to display
 106     :    * @param {number} duration - Duration in ms (0 = permanent until next update)
 107     :    */
 108     :   showMessage(message, duration = 3000) {
 109     :     // Clear any existing timeout
 110     :     if (this.messageTimeout) {
 111     :       clearTimeout(this.messageTimeout);
 112     :       this.messageTimeout = null;
 113     :     }
 114     : 
 115     :     // Store original and show message
 116     :     const originalText = this.modeIndicator.textContent;
 117     :     const originalColor = this.modeIndicator.style.color;
 118     : 
 119     :     this.modeIndicator.textContent = message;
 120     :     this.modeIndicator.style.color = 'var(--base04)';
 121     : 
 122     :     if (duration > 0) {
 123     :       this.messageTimeout = setTimeout(() => {
 124     :         this.modeIndicator.textContent = this.originalModeText || originalText;
 125     :         this.modeIndicator.style.color = originalColor;
 126     :         this.messageTimeout = null;
 127     :       }, duration);
 128     :     }
 129     :   }
 130     : 
 131     :   /**
 132     :    * Show the status line.
 133     :    */
 134     :   show() {
 135     :     this.element.style.display = 'flex';
 136     :   }
 137     : 
 138     :   /**
 139     :    * Hide the status line.
 140     :    */
 141     :   hide() {
 142     :     this.element.style.display = 'none';
 143     :   }
 144     : 
 145     :   /**
 146     :    * Get the status line element.
 147     :    */
 148     :   getElement() {
 149     :     return this.element;
 150     :   }
 151     : 
 152     :   /**
 153     :    * Destroy the status line.
 154     :    */
 155     :   destroy() {
 156     :     if (this.messageTimeout) {
 157     :       clearTimeout(this.messageTimeout);
 158     :     }
 159     :     this.element.remove();
 160     :   }
 161     : }
Removed regular file notes/izui-model.md:
   1     : # IZUI: Inverted Zooming User Interface
   2     : 
   3     : Research note documenting the IZUI navigation model for Peek.
   4     : 
   5     : ## Overview
   6     : 
   7     : IZUI (Inverted Zooming User Interface) inverts the traditional ZUI model:
   8     : 
   9     : | ZUI | IZUI |
  10     : |-----|------|
  11     : | Start from known root | Enter at any point |
  12     : | Navigate by zooming in | Navigate by zooming out (ESC) |
  13     : | Single entry point | Multiple entry points |
  14     : | Navigate forward to destination | Navigate backward to familiar ground |
  15     : 
  16     : ## Core Principles
  17     : 
  18     : 1. **Unbounded Entry**: Users can enter at any point via global hotkeys, commands, links, or extension actions.
  19     : 
  20     : 2. **Predictable Exit**: ESC always walks backward through navigation until reaching the entry point.
  21     : 
  22     : 3. **Context Preservation**: Each window preserves its internal state for return visits.
  23     : 
  24     : ## Implementation Status
  25     : 
  26     : ### Current: Minimal Parent Tracking (v1)
  27     : 
  28     : The initial implementation uses simple parent-child relationships:
  29     : - Windows track their opener via `source` address
  30     : - On ESC/close, focus restores to parent window
  31     : - No central stack data structure needed
  32     : 
  33     : See `app/izui.js` for implementation.
  34     : 
  35     : ### Future: Full Stack Model (v2)
  36     : 
  37     : For more complex navigation patterns, a full stack model may be needed.
  38     : 
  39     : #### Stack Structure
  40     : 
  41     : ```
  42     : IzuiStack {
  43     :   id: string              // Unique stack identifier
  44     :   entries: StackEntry[]   // Ordered list, index 0 = oldest
  45     :   entryMode: 'active' | 'transient'
  46     :   createdAt: number
  47     : }
  48     : 
  49     : StackEntry {
  50     :   windowId: number
  51     :   address: string
  52     :   params: object
  53     :   pushedAt: number
  54     : }
  55     : ```
  56     : 
  57     : #### Entry Modes
  58     : 
  59     : **Active Mode**: Peek was already focused when stack was created.
  60     : - ESC navigates internal state before closing
  61     : - Designed for deep navigation workflows
  62     : 
  63     : **Transient Mode**: Peek was invoked from another app via global hotkey.
  64     : - ESC closes immediately to return user to previous app
  65     : - Minimal friction for quick peek-and-return workflows
  66     : 
  67     : #### Stack Operations
  68     : 
  69     : - **Push**: Window opened from current context
  70     : - **Pop**: ESC pressed, window at root state
  71     : - **Destroy**: Last entry popped
  72     : 
  73     : ## Implementation Options Evaluated
  74     : 
  75     : ### Option A: Client-side only (pubsub coordination)
  76     : 
  77     : Stack state in each renderer, coordinated via pubsub.
  78     : 
  79     : **Pros**: Backend-agnostic
  80     : **Cons**: Eventually consistent, race conditions, lost state if coordinator closes
  81     : 
  82     : ### Option B: Background window coordinator
  83     : 
  84     : Stack state in `peek://app/background.html`, queried via pubsub.
  85     : 
  86     : **Pros**: Single source of truth, backend-agnostic
  87     : **Cons**: Latency on every query, complex message passing
  88     : 
  89     : ### Option C: Duplicate backend implementation
  90     : 
  91     : Implement in both Electron (TypeScript) and Tauri (Rust).
  92     : 
  93     : **Pros**: Synchronous, no race conditions
  94     : **Cons**: Duplicate code, maintenance burden
  95     : 
  96     : ### Option D: Minimal parent tracking (SELECTED)
  97     : 
  98     : Use existing `source` tracking, focus parent on close.
  99     : 
 100     : **Pros**: Simple, backend-agnostic, no new data structures
 101     : **Cons**: Limited to linear parent-child, no branching stacks
 102     : 
 103     : ## Security Considerations
 104     : 
 105     : ### Cross-Origin Navigation
 106     : 
 107     : | From | To | Behavior |
 108     : |------|----|----------|
 109     : | peek://app/* | peek://app/* | Same stack |
 110     : | peek://app/* | peek://ext/* | Same stack |
 111     : | peek://ext/* | peek://app/* | Same stack |
 112     : | peek://* | https://* | New stack (isolated) |
 113     : | https://* | peek://* | Blocked |
 114     : | https://* | https://* | New stack (isolated) |
 115     : 
 116     : External URLs should start isolated stacks to prevent untrusted content from manipulating Peek's navigation.
 117     : 
 118     : ## History Integration (Future)
 119     : 
 120     : Stack operations could optionally record to history:
 121     : 
 122     : ```javascript
 123     : trackNavigation(address, {
 124     :   source: 'izui',
 125     :   stackId: stack.id,
 126     :   action: 'push' | 'pop'
 127     : });
 128     : ```
 129     : 
 130     : ## Visual Indicators (Future)
 131     : 
 132     : Possible UI for stack depth:
 133     : - Breadcrumb trail
 134     : - Depth counter badge
 135     : - Mini-map of stack
 136     : 
 137     : ## Open Questions
 138     : 
 139     : 1. **Stack Branching**: Should stacks support multiple children from one parent?
 140     : 2. **Stack Persistence**: Should stacks survive app restart for session restore?
 141     : 3. **Multiple Stacks**: How should concurrent stacks interact?
 142     : 
 143     : ## References
 144     : 
 145     : - `notes/escape-navigation.md` - ESC behavior design
 146     : - `notes/design-vision.md` - Original IZUI concept
 147     : - `app/izui.js` - Current implementation
Modified regular file package.json:
    ...
 108  108:     "test:e2e:server": "./scripts/e2e-server.sh",
 109  109:     "interactive-test:e2e:full-sync": "./scripts/e2e-full-sync-test.sh",
 110  110:     "interactive-test:e2e:full-sync:auto": "./scripts/e2e-full-sync-test.sh --headless --build",
      111:     "test:e2e:mobile": "LOCAL_IP=localhost ./scripts/e2e-full-sync-test.sh --headless --build",
 111  112:     "test:mobile": "cd backend/tauri-mobile && npm test",
 112  113:     "test:extension": "node --test backend/extension/tests/*.test.js",
 113  114:     "extension:chrome": "backend/extension/scripts/launch-chrome.sh",
    ...
Modified regular file playwright.config.ts:
    ...
  31   31:         browserName: 'chromium',
  32   32:       },
  33   33:     },
  34     :     {
  35     :       name: 'editor',
  36     :       testMatch: /editor\/.*\.spec\.ts/,
  37     :       use: {
  38     :         // Editor tests run in browser
  39     :         browserName: 'chromium',
  40     :       },
  41     :     },
  42   34:     // Future projects:
  43   35:     // { name: 'mobile', testMatch: /mobile\/.*\.spec\.ts/ },
  44   36:     // { name: 'extension', testMatch: /extension\/.*\.spec\.ts/ },
    ...
Modified regular file preload.js:
    ...
 454  454:   // History operations (visits joined with addresses)
 455  455:   getHistory: (filter = {}) => {
 456  456:     return ipcRenderer.invoke('datastore-get-history', { filter });
 457     :   },
 458     : 
 459     :   // Item visit operations (modern URL history API)
 460     :   queryItemVisits: (filter = {}) => {
 461     :     return ipcRenderer.invoke('datastore-query-item-visits', { filter });
 462     :   },
 463     :   getItemVisits: (itemId, filter = {}) => {
 464     :     return ipcRenderer.invoke('datastore-get-item-visits', { itemId, filter });
 465     :   },
 466     :   recordItemVisit: (itemId, options = {}) => {
 467     :     return ipcRenderer.invoke('datastore-record-item-visit', { itemId, options });
 468  457:   }
 469  458: };
 470  459: 
    ...
Modified regular file schema/generated/sqlite-full.sql:
   1    1: -- Generated by schema/codegen.js
   2    2: -- Schema version: 1
   3     : -- Generated: 2026-01-30T11:28:43.966Z
        3: -- Generated: 2026-01-31T00:08:16.086Z
   4    4: -- DO NOT EDIT - regenerate with: yarn schema:codegen
   5    5: 
   6    6: -- Unified content storage - URLs, text notes, tagsets, and images
    ...
Modified regular file schema/generated/sqlite-sync.sql:
   1    1: -- Generated by schema/codegen.js
   2    2: -- Schema version: 1
   3     : -- Generated: 2026-01-30T11:28:43.966Z
        3: -- Generated: 2026-01-31T00:08:16.091Z
   4    4: -- DO NOT EDIT - regenerate with: yarn schema:codegen
   5    5: 
   6    6: -- Unified content storage - URLs, text notes, tagsets, and images
    ...
Modified regular file schema/generated/types.rs:
   1    1: // Generated by schema/codegen.js
   2    2: // Schema version: 1
   3     : // Generated: 2026-01-30T11:28:43.967Z
        3: // Generated: 2026-01-31T00:08:16.091Z
   4    4: // DO NOT EDIT - regenerate with: yarn schema:codegen
   5    5: 
   6    6: use serde::{Deserialize, Serialize};
    ...
Modified regular file schema/generated/types.ts:
   1    1: /**
   2    2:  * Generated by schema/codegen.js
   3    3:  * Schema version: 1
   4     :  * Generated: 2026-01-30T11:28:43.966Z
        4:  * Generated: 2026-01-31T00:08:16.091Z
   5    5:  * DO NOT EDIT - regenerate with: yarn schema:codegen
   6    6:  */
   7    7: 
    ...
Modified executable file scripts/e2e-full-sync-test.sh:
    ...
 412  412: );
 413  413: 
 414  414: CREATE TABLE IF NOT EXISTS tags (
 415  415:     id INTEGERTEXT PRIMARY KEY AUTOINCREMENT,
 416  416:     name TEXT NOT NULL UNIQUE,
 417  417:     frequency INTEGER NOT NULL DEFAULT 0,
 418  418:     lastUsed TEXT NOT NULL,
    ...
 423  423: 
 424  424: CREATE TABLE IF NOT EXISTS item_tags (
 425  425:     item_id TEXT NOT NULL,
 426  426:     tag_id INTEGERTEXT NOT NULL,
 427  427:     created_at TEXT NOT NULL,
 428  428:     PRIMARY KEY (item_id, tag_id),
 429  429:     FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
    ...
 462  462:   ('ios-e2e-url-1', 'url', 'https://example.com/ios-origin-1', '', '', '', datetime('now'), datetime('now')),
 463  463:   ('ios-e2e-note-1', 'text', '', 'Note created on iOS', '', '', datetime('now'), datetime('now'));
 464  464: 
 465  465: -- Tags (TEXT IDs matching desktop/server format: tag_{timestamp}_{random9})
 466  466: INSERT INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt)
 467  467: VALUES
 468  468:   ('tag_e2e_ios_001', 'ios', 1, datetime('now'), 1.0, datetime('now'), datetime('now')),
 469  469:   ('tag_e2e_ios_002', 'e2e', 1, datetime('now'), 1.0, datetime('now'), datetime('now')),
 470  470:   ('tag_e2e_ios_003', 'note', 1, datetime('now'), 1.0, datetime('now'), datetime('now'));
 471  471: 
 472  472: -- Tag associations (using TEXT tag_id)
 473  473: INSERT INTO item_tags (item_id, tag_id, created_at) VALUES ('ios-e2e-url-1', 1'tag_e2e_ios_001', datetime('now'));
 474  474: INSERT INTO item_tags (item_id, tag_id, created_at) VALUES ('ios-e2e-url-1', 2'tag_e2e_ios_002', datetime('now'));
 475  475: INSERT INTO item_tags (item_id, tag_id, created_at) VALUES ('ios-e2e-note-1', 1'tag_e2e_ios_001', datetime('now'));
 476  476: INSERT INTO item_tags (item_id, tag_id, created_at) VALUES ('ios-e2e-note-1', 3'tag_e2e_ios_003', datetime('now'));
 477  477: SQLEOF
 478  478: 
 479  479: IOS_COUNT=$(sqlite3 "$IOS_DB" "SELECT COUNT(*) FROM items WHERE deleted_at IS NULL;")
    ...
 765  765: VALUES
 766  766:   ('ios-crossdev-1', 'url', '$CROSS_URL', '', '', '', datetime('now'), datetime('now'));
 767  767: 
 768  768: INSERT OR IGNORE INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt)
 769  769: VALUES ('tag_e2e_crossdev', 'cross-device', 1, datetime('now'), 1.0, datetime('now'), datetime('now'));
 770  770: 
 771  771: INSERT INTO item_tags (item_id, tag_id, created_at)
 772     : SELECT 'ios-crossdev-1', id, datetime('now') FROM tags WHERE name = 'cross-device';
      772: VALUES ('ios-crossdev-1', 'tag_e2e_crossdev', datetime('now'));
 773  773: SQLEOF
 774  774: 
 775  775: echo "  Seeded cross-device URL into iOS"
    ...
 808  808: INSERT INTO items (id, type, url, content, metadata, sync_source, created_at, updated_at)
 809  809: VALUES ('ios-tagset-1', 'tagset', '', '', '', '', datetime('now'), datetime('now'));
 810  810: 
 811  811: INSERT OR IGNORE INTO tags (id, name, frequency, lastUsed, frecencyScore, createdAt, updatedAt)
 812  812: VALUES
 813  813:   ('tag_e2e_shared', 'shared', 1, datetime('now'), 1.0, datetime('now'), datetime('now')),
 814  814:   ('tag_e2e_tagset', 'tagset', 1, datetime('now'), 1.0, datetime('now'), datetime('now'));
 815  815: 
 816  816: INSERT INTO item_tags (item_id, tag_id, created_at)
 817     : SELECT 'ios-tagset-1', id, datetime('now') FROM tags WHERE name = 'shared';
      817: VALUES ('ios-tagset-1', 'tag_e2e_shared', datetime('now'));
 818  818: INSERT INTO item_tags (item_id, tag_id, created_at)
 819     : SELECT 'ios-tagset-1', id, datetime('now') FROM tags WHERE name = 'tagset';
      819: VALUES ('ios-tagset-1', 'tag_e2e_tagset', datetime('now'));
 820  820: SQLEOF
 821  821: 
 822  822: echo "  Seeded cross-device tagset into iOS"
    ...
1100 1100: VALUES ('dup-ios-tagset-1', 'tagset', '', '', '', '', datetime('now'), datetime('now', '-1 day'));
1101 1101: 
1102 1102: INSERT INTO item_tags (item_id, tag_id, created_at)
1103     : SELECT 'dup-ios-tagset-1', id, datetime('now') FROM tags WHERE name IN ('shared', 'tagset');
     1103: VALUES ('dup-ios-tagset-1', 'tag_e2e_shared', datetime('now'));
     1104: INSERT INTO item_tags (item_id, tag_id, created_at)
     1105: VALUES ('dup-ios-tagset-1', 'tag_e2e_tagset', datetime('now'));
1104 1106: SQLEOF
1105 1107: echo "  Seeded 3 duplicates into iOS DB"
1106 1108: 
    ...
Removed regular file tests/editor/editor-folding.spec.ts:
   1     : /**
   2     :  * Editor Folding Tests
   3     :  *
   4     :  * Tests for CodeMirror markdown folding features (folditall-style).
   5     :  * Tests actual folding BEHAVIOR, not just that commands run without errors.
   6     :  *
   7     :  * Run with:
   8     :  *   npx playwright test tests/editor/ --project=editor
   9     :  */
  10     : 
  11     : import { test, expect, Page } from '@playwright/test';
  12     : import path from 'path';
  13     : import { fileURLToPath } from 'url';
  14     : import { createServer } from 'http';
  15     : import { readFileSync, existsSync } from 'fs';
  16     : 
  17     : const __filename = fileURLToPath(import.meta.url);
  18     : const __dirname = path.dirname(__filename);
  19     : const ROOT = path.join(__dirname, '../..');
  20     : 
  21     : // Simple static file server
  22     : let server: ReturnType<typeof createServer>;
  23     : let serverUrl: string;
  24     : 
  25     : const mimeTypes: Record<string, string> = {
  26     :   '.html': 'text/html',
  27     :   '.js': 'application/javascript',
  28     :   '.css': 'text/css',
  29     :   '.json': 'application/json',
  30     : };
  31     : 
  32     : function startServer(): Promise<string> {
  33     :   return new Promise((resolve) => {
  34     :     server = createServer((req, res) => {
  35     :       let filePath = path.join(ROOT, req.url || '/');
  36     : 
  37     :       if (req.url === '/' || req.url === '/test') {
  38     :         filePath = path.join(__dirname, 'test-page.html');
  39     :       }
  40     : 
  41     :       if (req.url?.startsWith('/node_modules/')) {
  42     :         filePath = path.join(ROOT, req.url);
  43     :       }
  44     : 
  45     :       const ext = path.extname(filePath);
  46     :       const contentType = mimeTypes[ext] || 'text/plain';
  47     : 
  48     :       try {
  49     :         if (existsSync(filePath)) {
  50     :           const content = readFileSync(filePath);
  51     :           res.writeHead(200, { 'Content-Type': contentType });
  52     :           res.end(content);
  53     :         } else {
  54     :           res.writeHead(404);
  55     :           res.end(`Not found: ${filePath}`);
  56     :         }
  57     :       } catch (err) {
  58     :         res.writeHead(500);
  59     :         res.end(`Error: ${err}`);
  60     :       }
  61     :     });
  62     : 
  63     :     server.listen(0, '127.0.0.1', () => {
  64     :       const addr = server.address();
  65     :       if (addr && typeof addr === 'object') {
  66     :         const url = `http://127.0.0.1:${addr.port}`;
  67     :         resolve(url);
  68     :       }
  69     :     });
  70     :   });
  71     : }
  72     : 
  73     : function stopServer() {
  74     :   if (server) {
  75     :     server.close();
  76     :   }
  77     : }
  78     : 
  79     : test.describe('Editor Folding @editor', () => {
  80     :   let page: Page;
  81     : 
  82     :   test.beforeAll(async ({ browser }) => {
  83     :     serverUrl = await startServer();
  84     :     page = await browser.newPage();
  85     : 
  86     :     page.on('console', msg => {
  87     :       if (msg.type() === 'error') {
  88     :         console.log('Page error:', msg.text());
  89     :       }
  90     :     });
  91     : 
  92     :     page.on('pageerror', err => {
  93     :       console.log('Page exception:', err.message);
  94     :     });
  95     : 
  96     :     await page.goto(`${serverUrl}/test`);
  97     :     await page.waitForSelector('body[data-ready="true"]', { timeout: 15000 });
  98     :   });
  99     : 
 100     :   test.afterAll(async () => {
 101     :     await page.close();
 102     :     stopServer();
 103     :   });
 104     : 
 105     :   // ==========================================================================
 106     :   // Helper: Count fold placeholders (indicates folded content)
 107     :   // ==========================================================================
 108     : 
 109     :   async function getFoldPlaceholderCount(): Promise<number> {
 110     :     return await page.evaluate(() => {
 111     :       return document.querySelectorAll('.cm-foldPlaceholder').length;
 112     :     });
 113     :   }
 114     : 
 115     :   async function getVisibleLineCount(): Promise<number> {
 116     :     return await page.evaluate(() => {
 117     :       // Count visible line elements in the editor
 118     :       const lines = document.querySelectorAll('.cm-line');
 119     :       return lines.length;
 120     :     });
 121     :   }
 122     : 
 123     :   // ==========================================================================
 124     :   // Basic Editor Setup
 125     :   // ==========================================================================
 126     : 
 127     :   test.describe('Editor Setup', () => {
 128     :     test('editor is initialized with content', async () => {
 129     :       const content = await page.evaluate(() => {
 130     :         return window.editorView?.state.doc.toString();
 131     :       });
 132     :       expect(content).toContain('# Level 1 Header');
 133     :       expect(content).toContain('###### Level 6');
 134     :     });
 135     : 
 136     :     test('fold gutter is visible', async () => {
 137     :       const hasFoldGutter = await page.evaluate(() => {
 138     :         return !!document.querySelector('.cm-foldGutter');
 139     :       });
 140     :       expect(hasFoldGutter).toBe(true);
 141     :     });
 142     : 
 143     :     test('no folds initially (no placeholders)', async () => {
 144     :       await page.evaluate(() => window.unfoldAll());
 145     :       await page.waitForTimeout(50);
 146     :       const count = await getFoldPlaceholderCount();
 147     :       expect(count).toBe(0);
 148     :     });
 149     :   });
 150     : 
 151     :   // ==========================================================================
 152     :   // foldAll / unfoldAll API Functions
 153     :   // ==========================================================================
 154     : 
 155     :   test.describe('Fold All / Unfold All API', () => {
 156     :     test.beforeEach(async () => {
 157     :       await page.evaluate(() => window.unfoldAll());
 158     :       await page.waitForTimeout(50);
 159     :     });
 160     : 
 161     :     test('foldAll creates fold placeholders', async () => {
 162     :       const beforeCount = await getFoldPlaceholderCount();
 163     :       expect(beforeCount).toBe(0);
 164     : 
 165     :       await page.evaluate(() => window.foldAll());
 166     :       await page.waitForTimeout(100);
 167     : 
 168     :       const afterCount = await getFoldPlaceholderCount();
 169     :       expect(afterCount).toBeGreaterThan(0);
 170     :     });
 171     : 
 172     :     test('unfoldAll removes all fold placeholders', async () => {
 173     :       // First fold all
 174     :       await page.evaluate(() => window.foldAll());
 175     :       await page.waitForTimeout(100);
 176     : 
 177     :       const foldedCount = await getFoldPlaceholderCount();
 178     :       expect(foldedCount).toBeGreaterThan(0);
 179     : 
 180     :       // Then unfold all
 181     :       await page.evaluate(() => window.unfoldAll());
 182     :       await page.waitForTimeout(100);
 183     : 
 184     :       const unfoldedCount = await getFoldPlaceholderCount();
 185     :       expect(unfoldedCount).toBe(0);
 186     :     });
 187     : 
 188     :     test('foldAll reduces visible line count', async () => {
 189     :       const beforeLines = await getVisibleLineCount();
 190     : 
 191     :       await page.evaluate(() => window.foldAll());
 192     :       await page.waitForTimeout(100);
 193     : 
 194     :       const afterLines = await getVisibleLineCount();
 195     :       expect(afterLines).toBeLessThan(beforeLines);
 196     :     });
 197     :   });
 198     : 
 199     :   // ==========================================================================
 200     :   // Header Folding (folditall behavior)
 201     :   // ==========================================================================
 202     : 
 203     :   test.describe('Header Folding Behavior', () => {
 204     :     test.beforeEach(async () => {
 205     :       await page.evaluate(() => window.unfoldAll());
 206     :       await page.waitForTimeout(50);
 207     :     });
 208     : 
 209     :     test('level 1 header is foldable', async () => {
 210     :       const result = await page.evaluate(() => {
 211     :         const line = window.editorView.state.doc.line(1);
 212     :         return window.foldable(line.from) !== null;
 213     :       });
 214     :       expect(result).toBe(true);
 215     :     });
 216     : 
 217     :     test('folding level 1 header hides content until next level 1 or EOF', async () => {
 218     :       // Fold at line 1 (# Level 1 Header)
 219     :       await page.evaluate(() => {
 220     :         window.setCursorLine(1);
 221     :         window.foldCode(window.editorView.state.selection.main.head);
 222     :       });
 223     :       await page.waitForTimeout(100);
 224     : 
 225     :       const placeholders = await getFoldPlaceholderCount();
 226     :       expect(placeholders).toBeGreaterThan(0);
 227     :     });
 228     : 
 229     :     test('level 2 header fold ends at next level 2 or higher', async () => {
 230     :       // Find line number for "## Level 2 - Features"
 231     :       const lineNum = await page.evaluate(() => {
 232     :         const doc = window.editorView.state.doc;
 233     :         for (let i = 1; i <= doc.lines; i++) {
 234     :           if (doc.line(i).text.startsWith('## Level 2 - Features')) {
 235     :             return i;
 236     :           }
 237     :         }
 238     :         return -1;
 239     :       });
 240     : 
 241     :       expect(lineNum).toBeGreaterThan(0);
 242     : 
 243     :       // Get the fold range
 244     :       const foldRange = await page.evaluate((ln) => {
 245     :         const doc = window.editorView.state.doc;
 246     :         const line = doc.line(ln);
 247     :         const range = window.foldable(line.from);
 248     :         if (!range) return null;
 249     : 
 250     :         // Find what line the fold ends at
 251     :         const endLine = doc.lineAt(range.to);
 252     :         return {
 253     :           startLine: ln,
 254     :           endLineNum: endLine.number,
 255     :           endLineText: endLine.text.substring(0, 50),
 256     :         };
 257     :       }, lineNum);
 258     : 
 259     :       expect(foldRange).not.toBeNull();
 260     :       // The fold should end before the next ## header
 261     :       expect(foldRange!.endLineNum).toBeGreaterThan(lineNum);
 262     :     });
 263     : 
 264     :     test('all 6 header levels are foldable', async () => {
 265     :       const results = await page.evaluate(() => {
 266     :         const doc = window.editorView.state.doc;
 267     :         const levels: Record<number, boolean> = {};
 268     : 
 269     :         for (let i = 1; i <= doc.lines; i++) {
 270     :           const line = doc.line(i);
 271     :           const match = line.text.match(/^(#{1,6})\s+/);
 272     :           if (match) {
 273     :             const level = match[1].length;
 274     :             if (!levels[level]) {
 275     :               levels[level] = window.foldable(line.from) !== null;
 276     :             }
 277     :           }
 278     :         }
 279     :         return levels;
 280     :       });
 281     : 
 282     :       expect(results[1]).toBe(true);
 283     :       expect(results[2]).toBe(true);
 284     :       expect(results[3]).toBe(true);
 285     :       expect(results[4]).toBe(true);
 286     :       expect(results[5]).toBe(true);
 287     :       expect(results[6]).toBe(true);
 288     :     });
 289     :   });
 290     : 
 291     :   // ==========================================================================
 292     :   // Vim Mode Fold Commands
 293     :   // ==========================================================================
 294     : 
 295     :   test.describe('Vim Fold Commands (actual behavior)', () => {
 296     :     test.beforeEach(async () => {
 297     :       await page.evaluate(() => {
 298     :         window.setVimMode(true);
 299     :         window.unfoldAll();
 300     :       });
 301     :       await page.waitForTimeout(100);
 302     :     });
 303     : 
 304     :     test.afterEach(async () => {
 305     :       await page.evaluate(() => {
 306     :         window.setVimMode(false);
 307     :         window.unfoldAll();
 308     :       });
 309     :     });
 310     : 
 311     :     test('zM actually folds content (creates placeholders)', async () => {
 312     :       const beforeCount = await getFoldPlaceholderCount();
 313     :       expect(beforeCount).toBe(0);
 314     : 
 315     :       // Execute zM via Vim
 316     :       await page.evaluate(() => {
 317     :         window.setCursorLine(1);
 318     :         const view = window.editorView;
 319     :         view.focus();
 320     :       });
 321     :       await page.waitForTimeout(50);
 322     : 
 323     :       // Type zM
 324     :       await page.keyboard.press('z');
 325     :       await page.keyboard.press('Shift+M');
 326     :       await page.waitForTimeout(100);
 327     : 
 328     :       const afterCount = await getFoldPlaceholderCount();
 329     :       expect(afterCount).toBeGreaterThan(0);
 330     :     });
 331     : 
 332     :     test('zR actually unfolds content (removes placeholders)', async () => {
 333     :       // First fold everything
 334     :       await page.evaluate(() => window.foldAll());
 335     :       await page.waitForTimeout(100);
 336     : 
 337     :       const foldedCount = await getFoldPlaceholderCount();
 338     :       expect(foldedCount).toBeGreaterThan(0);
 339     : 
 340     :       // Now use zR to unfold
 341     :       await page.evaluate(() => {
 342     :         window.setCursorLine(1);
 343     :         window.editorView.focus();
 344     :       });
 345     :       await page.waitForTimeout(50);
 346     : 
 347     :       await page.keyboard.press('z');
 348     :       await page.keyboard.press('Shift+R');
 349     :       await page.waitForTimeout(100);
 350     : 
 351     :       const afterCount = await getFoldPlaceholderCount();
 352     :       expect(afterCount).toBe(0);
 353     :     });
 354     : 
 355     :     test('zc folds at cursor position', async () => {
 356     :       const beforeCount = await getFoldPlaceholderCount();
 357     :       expect(beforeCount).toBe(0);
 358     : 
 359     :       // Position on a header and fold it
 360     :       await page.evaluate(() => {
 361     :         window.setCursorLine(1); // Level 1 header
 362     :         window.editorView.focus();
 363     :       });
 364     :       await page.waitForTimeout(50);
 365     : 
 366     :       await page.keyboard.press('z');
 367     :       await page.keyboard.press('c');
 368     :       await page.waitForTimeout(100);
 369     : 
 370     :       const afterCount = await getFoldPlaceholderCount();
 371     :       expect(afterCount).toBeGreaterThan(0);
 372     :     });
 373     : 
 374     :     test('zo unfolds at cursor position', async () => {
 375     :       // First fold at line 1
 376     :       await page.evaluate(() => {
 377     :         window.setCursorLine(1);
 378     :         window.foldCode(window.editorView.state.selection.main.head);
 379     :       });
 380     :       await page.waitForTimeout(100);
 381     : 
 382     :       const foldedCount = await getFoldPlaceholderCount();
 383     :       expect(foldedCount).toBeGreaterThan(0);
 384     : 
 385     :       // Now unfold with zo
 386     :       await page.evaluate(() => {
 387     :         window.setCursorLine(1);
 388     :         window.editorView.focus();
 389     :       });
 390     :       await page.waitForTimeout(50);
 391     : 
 392     :       await page.keyboard.press('z');
 393     :       await page.keyboard.press('o');
 394     :       await page.waitForTimeout(100);
 395     : 
 396     :       const afterCount = await getFoldPlaceholderCount();
 397     :       expect(afterCount).toBeLessThan(foldedCount);
 398     :     });
 399     : 
 400     :     test('za toggles fold (fold then unfold)', async () => {
 401     :       const initialCount = await getFoldPlaceholderCount();
 402     :       expect(initialCount).toBe(0);
 403     : 
 404     :       await page.evaluate(() => {
 405     :         window.setCursorLine(1);
 406     :         window.editorView.focus();
 407     :       });
 408     :       await page.waitForTimeout(50);
 409     : 
 410     :       // First za should fold
 411     :       await page.keyboard.press('z');
 412     :       await page.keyboard.press('a');
 413     :       await page.waitForTimeout(100);
 414     : 
 415     :       const afterFirstToggle = await getFoldPlaceholderCount();
 416     :       expect(afterFirstToggle).toBeGreaterThan(0);
 417     : 
 418     :       // Second za should unfold
 419     :       await page.keyboard.press('z');
 420     :       await page.keyboard.press('a');
 421     :       await page.waitForTimeout(100);
 422     : 
 423     :       const afterSecondToggle = await getFoldPlaceholderCount();
 424     :       expect(afterSecondToggle).toBe(0);
 425     :     });
 426     :   });
 427     : 
 428     :   // ==========================================================================
 429     :   // Click-to-Fold (gutter interaction)
 430     :   // ==========================================================================
 431     : 
 432     :   test.describe('Click-to-Fold', () => {
 433     :     test.beforeEach(async () => {
 434     :       await page.evaluate(() => {
 435     :         window.setVimMode(false);
 436     :         window.unfoldAll();
 437     :       });
 438     :       await page.waitForTimeout(50);
 439     :     });
 440     : 
 441     :     test('clicking fold gutter creates a fold placeholder', async () => {
 442     :       const beforeCount = await getFoldPlaceholderCount();
 443     :       expect(beforeCount).toBe(0);
 444     : 
 445     :       // Click the first fold marker in the gutter
 446     :       const clicked = await page.evaluate(() => {
 447     :         const gutterElements = document.querySelectorAll('.cm-foldGutter .cm-gutterElement');
 448     :         for (const el of gutterElements) {
 449     :           // Look for a gutter element that has fold indicator
 450     :           if (el.textContent && el.textContent.trim() !== '') {
 451     :             (el as HTMLElement).click();
 452     :             return true;
 453     :           }
 454     :         }
 455     :         // Try clicking any gutter element on a header line
 456     :         const firstGutter = gutterElements[0] as HTMLElement;
 457     :         if (firstGutter) {
 458     :           firstGutter.click();
 459     :           return true;
 460     :         }
 461     :         return false;
 462     :       });
 463     : 
 464     :       if (clicked) {
 465     :         await page.waitForTimeout(100);
 466     :         const afterCount = await getFoldPlaceholderCount();
 467     :         // Note: Click behavior may vary, but if it worked there should be a placeholder
 468     :         // This test validates the mechanism exists
 469     :       }
 470     : 
 471     :       expect(true).toBe(true); // Placeholder test - gutter click mechanism exists
 472     :     });
 473     :   });
 474     : 
 475     :   // ==========================================================================
 476     :   // List Folding (folditall feature)
 477     :   // ==========================================================================
 478     : 
 479     :   test.describe('List Item Folding', () => {
 480     :     test.beforeEach(async () => {
 481     :       await page.evaluate(() => window.unfoldAll());
 482     :       await page.waitForTimeout(50);
 483     :     });
 484     : 
 485     :     test('list item with children is foldable', async () => {
 486     :       // Find a parent list item (- Parent item with children)
 487     :       const result = await page.evaluate(() => {
 488     :         const doc = window.editorView.state.doc;
 489     :         for (let i = 1; i <= doc.lines; i++) {
 490     :           const line = doc.line(i);
 491     :           if (line.text.match(/^- Parent item with children/)) {
 492     :             const isFoldable = window.foldable(line.from) !== null;
 493     :             return { lineNum: i, text: line.text, foldable: isFoldable };
 494     :           }
 495     :         }
 496     :         return null;
 497     :       });
 498     : 
 499     :       expect(result).not.toBeNull();
 500     :       expect(result!.foldable).toBe(true);
 501     :     });
 502     : 
 503     :     test('nested list items create foldable regions', async () => {
 504     :       // Find lines with child items
 505     :       const result = await page.evaluate(() => {
 506     :         const doc = window.editorView.state.doc;
 507     :         const listItems: { lineNum: number; text: string; foldable: boolean; indent: number }[] = [];
 508     : 
 509     :         for (let i = 1; i <= doc.lines; i++) {
 510     :           const line = doc.line(i);
 511     :           const text = line.text;
 512     :           // Match list items
 513     :           if (/^\s*[-*+]\s/.test(text) || /^\s*\d+[.)]\s/.test(text)) {
 514     :             const indent = text.match(/^(\s*)/)?.[1].length || 0;
 515     :             const isFoldable = window.foldable(line.from) !== null;
 516     :             listItems.push({ lineNum: i, text: text.substring(0, 40), foldable: isFoldable, indent });
 517     :           }
 518     :         }
 519     :         return listItems;
 520     :       });
 521     : 
 522     :       expect(result.length).toBeGreaterThan(0);
 523     : 
 524     :       // At least some list items with children should be foldable
 525     :       const foldableItems = result.filter(item => item.foldable);
 526     :       expect(foldableItems.length).toBeGreaterThan(0);
 527     :     });
 528     : 
 529     :     test('folding list parent hides children', async () => {
 530     :       const beforeLines = await getVisibleLineCount();
 531     : 
 532     :       // Find and fold a parent list item
 533     :       const folded = await page.evaluate(() => {
 534     :         const doc = window.editorView.state.doc;
 535     :         for (let i = 1; i <= doc.lines; i++) {
 536     :           const line = doc.line(i);
 537     :           if (line.text.match(/^- Parent item with children/)) {
 538     :             const foldRange = window.foldable(line.from);
 539     :             if (foldRange) {
 540     :               window.foldCode(line.from);
 541     :               return true;
 542     :             }
 543     :           }
 544     :         }
 545     :         return false;
 546     :       });
 547     : 
 548     :       expect(folded).toBe(true);
 549     :       await page.waitForTimeout(100);
 550     : 
 551     :       const afterLines = await getVisibleLineCount();
 552     :       const placeholders = await getFoldPlaceholderCount();
 553     : 
 554     :       expect(placeholders).toBeGreaterThan(0);
 555     :       expect(afterLines).toBeLessThan(beforeLines);
 556     :     });
 557     : 
 558     :     test('deeply nested list items (grandchildren) are hidden when parent folds', async () => {
 559     :       // Find a grandchild line number
 560     :       const grandchildLineNum = await page.evaluate(() => {
 561     :         const doc = window.editorView.state.doc;
 562     :         for (let i = 1; i <= doc.lines; i++) {
 563     :           if (doc.line(i).text.includes('Grandchild item')) {
 564     :             return i;
 565     :           }
 566     :         }
 567     :         return -1;
 568     :       });
 569     : 
 570     :       expect(grandchildLineNum).toBeGreaterThan(0);
 571     : 
 572     :       // Fold the top-level parent list item
 573     :       await page.evaluate(() => {
 574     :         const doc = window.editorView.state.doc;
 575     :         for (let i = 1; i <= doc.lines; i++) {
 576     :           const line = doc.line(i);
 577     :           if (line.text.match(/^- Parent item with children/)) {
 578     :             window.foldCode(line.from);
 579     :             break;
 580     :           }
 581     :         }
 582     :       });
 583     :       await page.waitForTimeout(100);
 584     : 
 585     :       const placeholders = await getFoldPlaceholderCount();
 586     :       expect(placeholders).toBeGreaterThan(0);
 587     :     });
 588     : 
 589     :     test('simple list item without children is not foldable', async () => {
 590     :       const result = await page.evaluate(() => {
 591     :         const doc = window.editorView.state.doc;
 592     :         for (let i = 1; i <= doc.lines; i++) {
 593     :           const line = doc.line(i);
 594     :           if (line.text === '- Simple item (no children)') {
 595     :             const isFoldable = window.foldable(line.from) !== null;
 596     :             return { lineNum: i, foldable: isFoldable };
 597     :           }
 598     :         }
 599     :         return null;
 600     :       });
 601     : 
 602     :       expect(result).not.toBeNull();
 603     :       expect(result!.foldable).toBe(false);
 604     :     });
 605     :   });
 606     : 
 607     :   // ==========================================================================
 608     :   // Code Block Folding (folditall feature)
 609     :   // ==========================================================================
 610     : 
 611     :   test.describe('Code Block Folding', () => {
 612     :     test.beforeEach(async () => {
 613     :       await page.evaluate(() => window.unfoldAll());
 614     :       await page.waitForTimeout(50);
 615     :     });
 616     : 
 617     :     test('fenced code block opener is foldable', async () => {
 618     :       const result = await page.evaluate(() => {
 619     :         const doc = window.editorView.state.doc;
 620     :         for (let i = 1; i <= doc.lines; i++) {
 621     :           const line = doc.line(i);
 622     :           if (line.text.startsWith('```javascript')) {
 623     :             const isFoldable = window.foldable(line.from) !== null;
 624     :             return { lineNum: i, foldable: isFoldable };
 625     :           }
 626     :         }
 627     :         return null;
 628     :       });
 629     : 
 630     :       expect(result).not.toBeNull();
 631     :       expect(result!.foldable).toBe(true);
 632     :     });
 633     : 
 634     :     test('folding code block hides its contents', async () => {
 635     :       const beforeLines = await getVisibleLineCount();
 636     : 
 637     :       await page.evaluate(() => {
 638     :         const doc = window.editorView.state.doc;
 639     :         for (let i = 1; i <= doc.lines; i++) {
 640     :           const line = doc.line(i);
 641     :           if (line.text.startsWith('```javascript')) {
 642     :             window.foldCode(line.from);
 643     :             break;
 644     :           }
 645     :         }
 646     :       });
 647     :       await page.waitForTimeout(100);
 648     : 
 649     :       const afterLines = await getVisibleLineCount();
 650     :       const placeholders = await getFoldPlaceholderCount();
 651     : 
 652     :       expect(placeholders).toBeGreaterThan(0);
 653     :       expect(afterLines).toBeLessThan(beforeLines);
 654     :     });
 655     :   });
 656     : 
 657     :   // ==========================================================================
 658     :   // Spacebar Toggle (folditall feature)
 659     :   // ==========================================================================
 660     : 
 661     :   test.describe('Spacebar Toggle', () => {
 662     :     test.beforeEach(async () => {
 663     :       await page.evaluate(() => {
 664     :         window.setVimMode(true);
 665     :         window.unfoldAll();
 666     :       });
 667     :       await page.waitForTimeout(100);
 668     :     });
 669     : 
 670     :     test.afterEach(async () => {
 671     :       await page.evaluate(() => {
 672     :         window.setVimMode(false);
 673     :         window.unfoldAll();
 674     :       });
 675     :     });
 676     : 
 677     :     test('spacebar toggles fold like za', async () => {
 678     :       const initialCount = await getFoldPlaceholderCount();
 679     :       expect(initialCount).toBe(0);
 680     : 
 681     :       await page.evaluate(() => {
 682     :         window.setCursorLine(1);
 683     :         window.editorView.focus();
 684     :       });
 685     :       await page.waitForTimeout(50);
 686     : 
 687     :       // Press space to fold
 688     :       await page.keyboard.press('Space');
 689     :       await page.waitForTimeout(100);
 690     : 
 691     :       const afterFold = await getFoldPlaceholderCount();
 692     :       expect(afterFold).toBeGreaterThan(0);
 693     : 
 694     :       // Press space again to unfold
 695     :       await page.keyboard.press('Space');
 696     :       await page.waitForTimeout(100);
 697     : 
 698     :       const afterUnfold = await getFoldPlaceholderCount();
 699     :       expect(afterUnfold).toBe(0);
 700     :     });
 701     :   });
 702     : 
 703     :   // ==========================================================================
 704     :   // Fold from Any Line Within Region (folditall core feature)
 705     :   // ==========================================================================
 706     : 
 707     :   test.describe('Fold From Any Line In Region', () => {
 708     :     test.beforeEach(async () => {
 709     :       await page.evaluate(() => {
 710     :         window.setVimMode(true);
 711     :         window.unfoldAll();
 712     :       });
 713     :       await page.waitForTimeout(100);
 714     :     });
 715     : 
 716     :     test.afterEach(async () => {
 717     :       await page.evaluate(() => {
 718     :         window.setVimMode(false);
 719     :         window.unfoldAll();
 720     :       });
 721     :     });
 722     : 
 723     :     test('zc from middle of header section folds the containing header', async () => {
 724     :       // Find line 3 (content under level 1 header)
 725     :       const lineNum = 3;
 726     : 
 727     :       await page.evaluate((ln) => {
 728     :         window.setCursorLine(ln);
 729     :         window.editorView.focus();
 730     :       }, lineNum);
 731     :       await page.waitForTimeout(50);
 732     : 
 733     :       const beforeCount = await getFoldPlaceholderCount();
 734     :       expect(beforeCount).toBe(0);
 735     : 
 736     :       await page.keyboard.press('z');
 737     :       await page.keyboard.press('c');
 738     :       await page.waitForTimeout(100);
 739     : 
 740     :       const afterCount = await getFoldPlaceholderCount();
 741     :       expect(afterCount).toBeGreaterThan(0);
 742     :     });
 743     : 
 744     :     test('za from nested list child toggles parent list fold', async () => {
 745     :       // Find a child list item line
 746     :       const childLineNum = await page.evaluate(() => {
 747     :         const doc = window.editorView.state.doc;
 748     :         for (let i = 1; i <= doc.lines; i++) {
 749     :           if (doc.line(i).text.includes('Child item one')) {
 750     :             return i;
 751     :           }
 752     :         }
 753     :         return -1;
 754     :       });
 755     : 
 756     :       expect(childLineNum).toBeGreaterThan(0);
 757     : 
 758     :       await page.evaluate((ln) => {
 759     :         window.setCursorLine(ln);
 760     :         window.editorView.focus();
 761     :       }, childLineNum);
 762     :       await page.waitForTimeout(50);
 763     : 
 764     :       // za should fold the containing list parent
 765     :       await page.keyboard.press('z');
 766     :       await page.keyboard.press('a');
 767     :       await page.waitForTimeout(100);
 768     : 
 769     :       const afterFold = await getFoldPlaceholderCount();
 770     :       expect(afterFold).toBeGreaterThan(0);
 771     :     });
 772     :   });
 773     : 
 774     :   // ==========================================================================
 775     :   // Folditall-Specific: Nested Content Behavior
 776     :   // ==========================================================================
 777     : 
 778     :   test.describe('Folditall Nested Behavior', () => {
 779     :     test.beforeEach(async () => {
 780     :       await page.evaluate(() => window.unfoldAll());
 781     :       await page.waitForTimeout(50);
 782     :     });
 783     : 
 784     :     test('folding parent header hides child headers', async () => {
 785     :       // Fold "## Level 2 - Features" which contains ### Level 3, #### Level 4, etc.
 786     :       const result = await page.evaluate(() => {
 787     :         const doc = window.editorView.state.doc;
 788     :         let level2Line = -1;
 789     : 
 790     :         for (let i = 1; i <= doc.lines; i++) {
 791     :           if (doc.line(i).text.startsWith('## Level 2 - Features')) {
 792     :             level2Line = i;
 793     :             break;
 794     :           }
 795     :         }
 796     : 
 797     :         if (level2Line === -1) return { error: 'Level 2 header not found' };
 798     : 
 799     :         // Get content before folding
 800     :         const visibleLinesBefore = document.querySelectorAll('.cm-line').length;
 801     : 
 802     :         // Fold at level 2
 803     :         const line = doc.line(level2Line);
 804     :         window.foldCode(line.from);
 805     : 
 806     :         return {
 807     :           level2Line,
 808     :           visibleLinesBefore,
 809     :         };
 810     :       });
 811     : 
 812     :       expect(result.level2Line).toBeGreaterThan(0);
 813     : 
 814     :       await page.waitForTimeout(100);
 815     : 
 816     :       const visibleLinesAfter = await getVisibleLineCount();
 817     :       const placeholders = await getFoldPlaceholderCount();
 818     : 
 819     :       // After folding level 2, visible lines should decrease and placeholder should appear
 820     :       expect(placeholders).toBeGreaterThan(0);
 821     :       expect(visibleLinesAfter).toBeLessThan(result.visibleLinesBefore!);
 822     :     });
 823     : 
 824     :     test('deeply nested headers (level 5, 6) are individually foldable', async () => {
 825     :       const result = await page.evaluate(() => {
 826     :         const doc = window.editorView.state.doc;
 827     :         const foldableHeaders: { level: number; line: number; foldable: boolean }[] = [];
 828     : 
 829     :         for (let i = 1; i <= doc.lines; i++) {
 830     :           const lineText = doc.line(i).text;
 831     :           const match = lineText.match(/^(#{5,6})\s+/);
 832     :           if (match) {
 833     :             const level = match[1].length;
 834     :             const line = doc.line(i);
 835     :             const isFoldable = window.foldable(line.from) !== null;
 836     :             foldableHeaders.push({ level, line: i, foldable: isFoldable });
 837     :           }
 838     :         }
 839     : 
 840     :         return foldableHeaders;
 841     :       });
 842     : 
 843     :       // Should have found level 5 and 6 headers
 844     :       const level5 = result.filter(h => h.level === 5);
 845     :       const level6 = result.filter(h => h.level === 6);
 846     : 
 847     :       expect(level5.length).toBeGreaterThan(0);
 848     :       expect(level6.length).toBeGreaterThan(0);
 849     : 
 850     :       // They should all be foldable
 851     :       for (const h of result) {
 852     :         expect(h.foldable).toBe(true);
 853     :       }
 854     :     });
 855     :   });
 856     : 
 857     :   // ==========================================================================
 858     :   // Status Line (vim-style status bar)
 859     :   // ==========================================================================
 860     : 
 861     :   test.describe('Status Line', () => {
 862     :     test.beforeEach(async () => {
 863     :       await page.evaluate(() => {
 864     :         window.setVimMode(true);
 865     :         window.unfoldAll();
 866     :       });
 867     :       await page.waitForTimeout(100);
 868     :     });
 869     : 
 870     :     test.afterEach(async () => {
 871     :       await page.evaluate(() => {
 872     :         window.setVimMode(false);
 873     :       });
 874     :     });
 875     : 
 876     :     test('status line shows position info', async () => {
 877     :       // Move cursor to line 5
 878     :       await page.evaluate(() => {
 879     :         window.setCursorLine(5);
 880     :       });
 881     :       await page.waitForTimeout(100);
 882     : 
 883     :       const positionText = await page.evaluate(() => {
 884     :         const posInfo = document.querySelector('.vim-position-info');
 885     :         return posInfo?.textContent || '';
 886     :       });
 887     : 
 888     :       expect(positionText).toContain('Ln 5');
 889     :       expect(positionText).toContain('Col');
 890     :     });
 891     : 
 892     :     test('status line updates on cursor movement', async () => {
 893     :       // Move to line 1
 894     :       await page.evaluate(() => {
 895     :         window.setCursorLine(1);
 896     :       });
 897     :       await page.waitForTimeout(100);
 898     : 
 899     :       const pos1 = await page.evaluate(() => {
 900     :         return document.querySelector('.vim-position-info')?.textContent || '';
 901     :       });
 902     :       expect(pos1).toContain('Ln 1');
 903     : 
 904     :       // Move to line 10
 905     :       await page.evaluate(() => {
 906     :         window.setCursorLine(10);
 907     :       });
 908     :       await page.waitForTimeout(100);
 909     : 
 910     :       const pos2 = await page.evaluate(() => {
 911     :         return document.querySelector('.vim-position-info')?.textContent || '';
 912     :       });
 913     :       expect(pos2).toContain('Ln 10');
 914     :     });
 915     : 
 916     :     test('status line shows NORMAL mode initially', async () => {
 917     :       const modeText = await page.evaluate(() => {
 918     :         const modeIndicator = document.querySelector('.vim-mode-indicator');
 919     :         return modeIndicator?.textContent || '';
 920     :       });
 921     : 
 922     :       expect(modeText).toBe('NORMAL');
 923     :     });
 924     : 
 925     :     test('status line shows INSERT mode when entering insert mode', async () => {
 926     :       await page.evaluate(() => {
 927     :         window.setCursorLine(1);
 928     :         window.editorView.focus();
 929     :       });
 930     :       await page.waitForTimeout(50);
 931     : 
 932     :       // Press 'i' to enter insert mode
 933     :       await page.keyboard.press('i');
 934     :       await page.waitForTimeout(100);
 935     : 
 936     :       const modeText = await page.evaluate(() => {
 937     :         const modeIndicator = document.querySelector('.vim-mode-indicator');
 938     :         return modeIndicator?.textContent || '';
 939     :       });
 940     : 
 941     :       expect(modeText).toContain('INSERT');
 942     : 
 943     :       // Press Escape to exit insert mode
 944     :       await page.keyboard.press('Escape');
 945     :       await page.waitForTimeout(100);
 946     : 
 947     :       const normalText = await page.evaluate(() => {
 948     :         const modeIndicator = document.querySelector('.vim-mode-indicator');
 949     :         return modeIndicator?.textContent || '';
 950     :       });
 951     : 
 952     :       expect(normalText).toBe('NORMAL');
 953     :     });
 954     : 
 955     :     test('status line shows VISUAL mode when entering visual mode', async () => {
 956     :       await page.evaluate(() => {
 957     :         window.setCursorLine(1);
 958     :         window.editorView.focus();
 959     :       });
 960     :       await page.waitForTimeout(50);
 961     : 
 962     :       // Press 'v' to enter visual mode
 963     :       await page.keyboard.press('v');
 964     :       await page.waitForTimeout(100);
 965     : 
 966     :       const modeText = await page.evaluate(() => {
 967     :         const modeIndicator = document.querySelector('.vim-mode-indicator');
 968     :         return modeIndicator?.textContent || '';
 969     :       });
 970     : 
 971     :       expect(modeText).toContain('VISUAL');
 972     : 
 973     :       // Press Escape to exit visual mode
 974     :       await page.keyboard.press('Escape');
 975     :     });
 976     :   });
 977     : });
 978     : 
 979     : // TypeScript declarations
 980     : declare global {
 981     :   interface Window {
 982     :     editorView: any;
 983     :     foldAll: () => boolean;
 984     :     unfoldAll: () => boolean;
 985     :     foldCode: (pos: number) => boolean;
 986     :     unfoldCode: (pos: number) => boolean;
 987     :     foldable: (pos: number) => { from: number; to: number } | null;
 988     :     setVimMode: (enabled: boolean) => void;
 989     :     getCursorLine: () => number;
 990     :     setCursorLine: (lineNum: number) => void;
 991     :   }
 992     : }
Removed regular file tests/editor/test-page.html:
   1     : <!DOCTYPE html>
   2     : <html lang="en">
   3     : <head>
   4     :   <meta charset="UTF-8">
   5     :   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   6     :   <title>Editor Folding Test Page</title>
   7     :   <script type="importmap">
   8     :   {
   9     :     "imports": {
  10     :       "@codemirror/state": "/node_modules/@codemirror/state/dist/index.js",
  11     :       "@codemirror/view": "/node_modules/@codemirror/view/dist/index.js",
  12     :       "@codemirror/commands": "/node_modules/@codemirror/commands/dist/index.js",
  13     :       "@codemirror/language": "/node_modules/@codemirror/language/dist/index.js",
  14     :       "@codemirror/autocomplete": "/node_modules/@codemirror/autocomplete/dist/index.js",
  15     :       "@codemirror/lang-markdown": "/node_modules/@codemirror/lang-markdown/dist/index.js",
  16     :       "@codemirror/lang-html": "/node_modules/@codemirror/lang-html/dist/index.js",
  17     :       "@codemirror/lang-css": "/node_modules/@codemirror/lang-css/dist/index.js",
  18     :       "@codemirror/lang-javascript": "/node_modules/@codemirror/lang-javascript/dist/index.js",
  19     :       "@codemirror/theme-one-dark": "/node_modules/@codemirror/theme-one-dark/dist/index.js",
  20     :       "@codemirror/search": "/node_modules/@codemirror/search/dist/index.js",
  21     :       "@replit/codemirror-vim": "/node_modules/@replit/codemirror-vim/dist/index.js",
  22     :       "@lezer/common": "/node_modules/@lezer/common/dist/index.js",
  23     :       "@lezer/highlight": "/node_modules/@lezer/highlight/dist/index.js",
  24     :       "@lezer/lr": "/node_modules/@lezer/lr/dist/index.js",
  25     :       "@lezer/markdown": "/node_modules/@lezer/markdown/dist/index.js",
  26     :       "@lezer/html": "/node_modules/@lezer/html/dist/index.js",
  27     :       "@lezer/css": "/node_modules/@lezer/css/dist/index.js",
  28     :       "@lezer/javascript": "/node_modules/@lezer/javascript/dist/index.js",
  29     :       "crelt": "/node_modules/crelt/index.js",
  30     :       "style-mod": "/node_modules/style-mod/src/style-mod.js",
  31     :       "w3c-keyname": "/node_modules/w3c-keyname/index.js",
  32     :       "@marijn/find-cluster-break": "/node_modules/@marijn/find-cluster-break/src/index.js"
  33     :     }
  34     :   }
  35     :   </script>
  36     :   <style>
  37     :     :root {
  38     :       /* Base16 Tomorrow Night theme */
  39     :       --base00: #1d1f21;
  40     :       --base01: #282a2e;
  41     :       --base02: #373b41;
  42     :       --base03: #969896;
  43     :       --base04: #b4b7b4;
  44     :       --base05: #c5c8c6;
  45     :       --base06: #e0e0e0;
  46     :       --base07: #ffffff;
  47     :       --base08: #cc6666;
  48     :       --base09: #de935f;
  49     :       --base0A: #f0c674;
  50     :       --base0B: #b5bd68;
  51     :       --base0C: #8abeb7;
  52     :       --base0D: #81a2be;
  53     :       --base0E: #b294bb;
  54     :       --base0F: #a3685a;
  55     :       --theme-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
  56     :     }
  57     :     body {
  58     :       margin: 0;
  59     :       padding: 20px;
  60     :       background: var(--base00);
  61     :       color: var(--base05);
  62     :       font-family: var(--theme-font-mono);
  63     :     }
  64     :     #editor-container {
  65     :       width: 100%;
  66     :       height: 600px;
  67     :       border: 1px solid var(--base02);
  68     :       border-radius: 8px;
  69     :       overflow: hidden;
  70     :     }
  71     :     .cm-editor {
  72     :       height: 100%;
  73     :     }
  74     :     #controls {
  75     :       margin-bottom: 16px;
  76     :       display: flex;
  77     :       gap: 12px;
  78     :       align-items: center;
  79     :     }
  80     :     button {
  81     :       background: var(--base02);
  82     :       color: var(--base05);
  83     :       border: 1px solid var(--base03);
  84     :       padding: 8px 16px;
  85     :       border-radius: 4px;
  86     :       cursor: pointer;
  87     :       font-family: inherit;
  88     :     }
  89     :     button:hover {
  90     :       background: var(--base03);
  91     :     }
  92     :     label {
  93     :       display: flex;
  94     :       align-items: center;
  95     :       gap: 8px;
  96     :     }
  97     :     #status {
  98     :       margin-top: 16px;
  99     :       padding: 12px;
 100     :       background: var(--base01);
 101     :       border-radius: 4px;
 102     :       font-size: 12px;
 103     :     }
 104     :   </style>
 105     : </head>
 106     : <body>
 107     :   <div id="controls">
 108     :     <label>
 109     :       <input type="checkbox" id="vim-toggle">
 110     :       Vim Mode
 111     :     </label>
 112     :     <button id="fold-all">Fold All (zM)</button>
 113     :     <button id="unfold-all">Unfold All (zR)</button>
 114     :   </div>
 115     : 
 116     :   <div id="editor-container"></div>
 117     : 
 118     :   <!-- Vim-style status line -->
 119     :   <div id="vim-status-line" style="display: none; justify-content: space-between; align-items: center; padding: 4px 12px; background: var(--base00); border-top: 1px solid var(--base02); min-height: 22px; font-family: var(--theme-font-mono); font-size: 12px;">
 120     :     <span class="vim-mode-indicator" style="color: var(--base0A); font-weight: 600;">NORMAL</span>
 121     :     <span class="vim-position-info" style="color: var(--base04);">Ln 1, Col 1</span>
 122     :   </div>
 123     : 
 124     :   <div id="status">
 125     :     <div id="fold-count">Folds: 0</div>
 126     :     <div id="cursor-pos">Cursor: 1:1</div>
 127     :   </div>
 128     : 
 129     :   <script type="module">
 130     :     import { EditorState, Compartment } from '@codemirror/state';
 131     :     import {
 132     :       EditorView,
 133     :       keymap,
 134     :       lineNumbers,
 135     :       highlightActiveLine,
 136     :       highlightActiveLineGutter,
 137     :       drawSelection
 138     :     } from '@codemirror/view';
 139     :     import { defaultKeymap, history, historyKeymap, indentWithTab } from '@codemirror/commands';
 140     :     import { markdown, markdownLanguage } from '@codemirror/lang-markdown';
 141     :     import {
 142     :       syntaxHighlighting,
 143     :       defaultHighlightStyle,
 144     :       bracketMatching,
 145     :       indentOnInput,
 146     :       foldGutter,
 147     :       foldService,
 148     :       codeFolding,
 149     :       foldAll,
 150     :       unfoldAll,
 151     :       foldCode,
 152     :       unfoldCode,
 153     :       foldable,
 154     :       foldedRanges,
 155     :       foldEffect,
 156     :       unfoldEffect
 157     :     } from '@codemirror/language';
 158     :     import { vim, Vim, getCM } from '@replit/codemirror-vim';
 159     :     import { searchKeymap, highlightSelectionMatches } from '@codemirror/search';
 160     : 
 161     :     // Helper: Find folded range at a position
 162     :     function findFoldedRangeAt(state, pos) {
 163     :       const folded = foldedRanges(state);
 164     :       let result = null;
 165     :       folded.between(0, state.doc.length, (from, to) => {
 166     :         if (pos >= from && pos <= to) {
 167     :           result = { from, to };
 168     :         }
 169     :       });
 170     :       return result;
 171     :     }
 172     : 
 173     :     // Define vim fold commands using folditall-style region finding
 174     :     Vim.defineAction('foldAll', (cm) => {
 175     :       foldAll(cm.cm6);
 176     :     });
 177     : 
 178     :     Vim.defineAction('unfoldAll', (cm) => {
 179     :       unfoldAll(cm.cm6);
 180     :     });
 181     : 
 182     :     Vim.defineAction('foldCode', (cm) => {
 183     :       const view = cm.cm6;
 184     :       const pos = view.state.selection.main.head;
 185     :       const lineNum = view.state.doc.lineAt(pos).number;
 186     : 
 187     :       const foldStart = findContainingFoldStart(view.state, lineNum);
 188     :       if (foldStart !== null) {
 189     :         const foldRange = foldable(view.state, foldStart, foldStart);
 190     :         if (foldRange) {
 191     :           view.dispatch({
 192     :             effects: foldEffect.of({ from: foldRange.from, to: foldRange.to })
 193     :           });
 194     :         }
 195     :       }
 196     :     });
 197     : 
 198     :     Vim.defineAction('unfoldCode', (cm) => {
 199     :       const view = cm.cm6;
 200     :       const pos = view.state.selection.main.head;
 201     :       const line = view.state.doc.lineAt(pos);
 202     :       const lineNum = line.number;
 203     : 
 204     :       // First check if we're in a folded range
 205     :       const foldedRange = findFoldedRangeAt(view.state, pos);
 206     :       if (foldedRange) {
 207     :         view.dispatch({
 208     :           effects: unfoldEffect.of({ from: foldedRange.from, to: foldedRange.to })
 209     :         });
 210     :         return;
 211     :       }
 212     : 
 213     :       // Check if there's a fold starting at the end of current line
 214     :       const foldAtLineEnd = findFoldedRangeAt(view.state, line.to);
 215     :       if (foldAtLineEnd) {
 216     :         view.dispatch({
 217     :           effects: unfoldEffect.of({ from: foldAtLineEnd.from, to: foldAtLineEnd.to })
 218     :         });
 219     :         return;
 220     :       }
 221     : 
 222     :       const foldStart = findContainingFoldStart(view.state, lineNum);
 223     :       if (foldStart !== null) {
 224     :         const foldStartLine = view.state.doc.lineAt(foldStart);
 225     :         const foldRange = foldable(view.state, foldStartLine.from, foldStartLine.to);
 226     :         if (foldRange) {
 227     :           const folded = foldedRanges(view.state);
 228     :           let isFolded = false;
 229     :           folded.between(foldRange.from, foldRange.to, (from) => {
 230     :             if (from === foldRange.from) isFolded = true;
 231     :           });
 232     :           if (isFolded) {
 233     :             view.dispatch({
 234     :               effects: unfoldEffect.of({ from: foldRange.from, to: foldRange.to })
 235     :             });
 236     :           }
 237     :         }
 238     :       }
 239     :     });
 240     : 
 241     :     Vim.defineAction('toggleFold', (cm) => {
 242     :       const view = cm.cm6;
 243     :       const pos = view.state.selection.main.head;
 244     :       const lineNum = view.state.doc.lineAt(pos).number;
 245     : 
 246     :       const foldStart = findContainingFoldStart(view.state, lineNum);
 247     :       if (foldStart === null) return;
 248     : 
 249     :       const line = view.state.doc.lineAt(foldStart);
 250     :       const foldRange = foldable(view.state, line.from, line.to);
 251     :       if (!foldRange) return;
 252     : 
 253     :       const folded = foldedRanges(view.state);
 254     :       let isFolded = false;
 255     :       folded.between(foldRange.from, foldRange.to, (from) => {
 256     :         if (from === foldRange.from) isFolded = true;
 257     :       });
 258     : 
 259     :       if (isFolded) {
 260     :         view.dispatch({
 261     :           effects: unfoldEffect.of({ from: foldRange.from, to: foldRange.to })
 262     :         });
 263     :       } else {
 264     :         view.dispatch({
 265     :           effects: foldEffect.of({ from: foldRange.from, to: foldRange.to })
 266     :         });
 267     :       }
 268     :     });
 269     : 
 270     :     // Map vim fold commands
 271     :     Vim.mapCommand('zc', 'action', 'foldCode', {}, { context: 'normal' });
 272     :     Vim.mapCommand('zo', 'action', 'unfoldCode', {}, { context: 'normal' });
 273     :     Vim.mapCommand('za', 'action', 'toggleFold', {}, { context: 'normal' });
 274     :     Vim.mapCommand('zM', 'action', 'foldAll', {}, { context: 'normal' });
 275     :     Vim.mapCommand('zR', 'action', 'unfoldAll', {}, { context: 'normal' });
 276     :     Vim.mapCommand('zr', 'action', 'unfoldAll', {}, { context: 'normal' });
 277     :     Vim.mapCommand('zm', 'action', 'foldAll', {}, { context: 'normal' });
 278     :     // Space toggles fold (like za) - folditall behavior
 279     :     Vim.mapCommand('<Space>', 'action', 'toggleFold', {}, { context: 'normal' });
 280     : 
 281     :     // Test content with all folding types
 282     :     const TEST_CONTENT = `# Level 1 Header - Main Document
 283     : 
 284     : This content is under a level 1 header.
 285     : 
 286     : ## Level 2 - Features
 287     : 
 288     : Content under level 2.
 289     : 
 290     : ### Level 3 - Folding Types
 291     : 
 292     : We support multiple folding types.
 293     : 
 294     : #### Level 4 - Header Folding
 295     : 
 296     : Headers fold everything until the next header of same or higher level.
 297     : 
 298     : ##### Level 5 - Deep Nesting
 299     : 
 300     : This is deeply nested content.
 301     : 
 302     : ###### Level 6 - Maximum Depth
 303     : 
 304     : This is the deepest header level supported.
 305     : 
 306     : Back to level 5 content.
 307     : 
 308     : ##### Level 5 - Another Section
 309     : 
 310     : Another level 5 section.
 311     : 
 312     : #### Level 4 - List Folding
 313     : 
 314     : Lists with children are foldable:
 315     : 
 316     : - Parent item with children
 317     :   - Child item one
 318     :   - Child item two
 319     :     - Grandchild item
 320     :     - Another grandchild
 321     :   - Child item three
 322     : - Simple item (no children)
 323     : - Another parent
 324     :   - Single child
 325     : 
 326     : Numbered lists also fold:
 327     : 
 328     : 1. First parent
 329     :    1. Sub-item one
 330     :    2. Sub-item two
 331     : 2. Second parent
 332     :    - Mixed child
 333     :    - Another mixed
 334     : 
 335     : #### Level 4 - Code Block Folding
 336     : 
 337     : Top-level code blocks fold their contents:
 338     : 
 339     : \`\`\`javascript
 340     : function example() {
 341     :     if (condition) {
 342     :         doSomething();
 343     :     }
 344     :     return result;
 345     : }
 346     : 
 347     : class MyClass {
 348     :     constructor() {
 349     :         this.x = 1;
 350     :     }
 351     : 
 352     :     method() {
 353     :         return this.x;
 354     :     }
 355     : }
 356     : \`\`\`
 357     : 
 358     : ### Level 3 - Vim Fold Commands
 359     : 
 360     : Test these vim commands (enable vim mode first):
 361     : 
 362     : | Command | Action |
 363     : |---------|--------|
 364     : | \`za\` | Toggle fold under cursor |
 365     : | \`zo\` | Open fold under cursor |
 366     : | \`zc\` | Close fold under cursor |
 367     : | \`zR\` | Open all folds |
 368     : | \`zM\` | Close all folds |
 369     : | \`zr\` | Reduce folding (open one level) |
 370     : | \`zm\` | More folding (close one level) |
 371     : 
 372     : ## Level 2 - Another Top Section
 373     : 
 374     : This tests that level 2 properly ends the previous level 2 section.
 375     : 
 376     : ### Level 3 - Final Nested
 377     : 
 378     : Final nested content.
 379     : 
 380     : ## Level 2 - Conclusion
 381     : 
 382     : End of test document.
 383     : `;
 384     : 
 385     :     // Compartments for runtime-reconfigurable extensions
 386     :     const vimCompartment = new Compartment();
 387     : 
 388     :     // ========================================================================
 389     :     // Folditall Algorithm Helpers
 390     :     // ========================================================================
 391     : 
 392     :     function getHeaderLevel(text) {
 393     :       const match = text.match(/^(#{1,6})\s+/);
 394     :       return match ? match[1].length : 0;
 395     :     }
 396     : 
 397     :     function isListItem(text) {
 398     :       return /^\s*[-*+]\s/.test(text) || /^\s*\d+[.)]\s/.test(text);
 399     :     }
 400     : 
 401     :     function getIndent(text) {
 402     :       let indent = 0;
 403     :       for (const char of text) {
 404     :         if (char === ' ') indent++;
 405     :         else if (char === '\t') indent += 2;
 406     :         else break;
 407     :       }
 408     :       return indent;
 409     :     }
 410     : 
 411     :     function isBlankLine(text) {
 412     :       return /^\s*$/.test(text);
 413     :     }
 414     : 
 415     :     function isFencedCodeBlockOpener(text) {
 416     :       return /^(`{3,}|~{3,})/.test(text.trim());
 417     :     }
 418     : 
 419     :     function findClosingFence(doc, openerLineNum) {
 420     :       const openerLine = doc.line(openerLineNum);
 421     :       const openerText = openerLine.text.trim();
 422     :       const match = openerText.match(/^(`{3,}|~{3,})/);
 423     :       if (!match) return null;
 424     : 
 425     :       const fenceChar = match[1][0];
 426     :       const fenceLen = match[1].length;
 427     :       const totalLines = doc.lines;
 428     : 
 429     :       for (let i = openerLineNum + 1; i <= totalLines; i++) {
 430     :         const line = doc.line(i);
 431     :         const trimmed = line.text.trim();
 432     :         const closeMatch = trimmed.match(new RegExp(`^${fenceChar}{${fenceLen},}$`));
 433     :         if (closeMatch) {
 434     :           return i;
 435     :         }
 436     :       }
 437     :       return null;
 438     :     }
 439     : 
 440     :     function findNextNonBlank(doc, lineNum) {
 441     :       const totalLines = doc.lines;
 442     :       for (let i = lineNum + 1; i <= totalLines; i++) {
 443     :         const line = doc.line(i);
 444     :         if (!isBlankLine(line.text)) {
 445     :           return i;
 446     :         }
 447     :       }
 448     :       return null;
 449     :     }
 450     : 
 451     :     function canStartFold(text) {
 452     :       if (getHeaderLevel(text) > 0) return true;
 453     :       if (isListItem(text)) return true;
 454     :       if (isFencedCodeBlockOpener(text)) return true;
 455     :       if (getIndent(text) === 0 && !isBlankLine(text)) return true;
 456     :       return false;
 457     :     }
 458     : 
 459     :     function hasFoldableChildren(doc, lineNum) {
 460     :       const line = doc.line(lineNum);
 461     :       const text = line.text;
 462     : 
 463     :       if (getHeaderLevel(text) > 0) return true;
 464     : 
 465     :       if (isFencedCodeBlockOpener(text)) {
 466     :         return findClosingFence(doc, lineNum) !== null;
 467     :       }
 468     : 
 469     :       const currentIndent = getIndent(text);
 470     :       const nextNonBlankNum = findNextNonBlank(doc, lineNum);
 471     : 
 472     :       if (nextNonBlankNum === null) return false;
 473     : 
 474     :       const nextLine = doc.line(nextNonBlankNum);
 475     :       const nextText = nextLine.text;
 476     : 
 477     :       if (getHeaderLevel(nextText) > 0) return false;
 478     : 
 479     :       return getIndent(nextText) > currentIndent;
 480     :     }
 481     : 
 482     :     function findFoldEnd(doc, lineNum) {
 483     :       const line = doc.line(lineNum);
 484     :       const text = line.text;
 485     :       const totalLines = doc.lines;
 486     :       const headerLevel = getHeaderLevel(text);
 487     : 
 488     :       if (headerLevel > 0) {
 489     :         for (let i = lineNum + 1; i <= totalLines; i++) {
 490     :           const checkLine = doc.line(i);
 491     :           const checkLevel = getHeaderLevel(checkLine.text);
 492     :           if (checkLevel > 0 && checkLevel <= headerLevel) {
 493     :             return i - 1;
 494     :           }
 495     :         }
 496     :         return totalLines;
 497     :       }
 498     : 
 499     :       if (isFencedCodeBlockOpener(text)) {
 500     :         const closingLine = findClosingFence(doc, lineNum);
 501     :         return closingLine !== null ? closingLine : lineNum;
 502     :       }
 503     : 
 504     :       const startIndent = getIndent(text);
 505     :       let lastContentLine = lineNum;
 506     : 
 507     :       for (let i = lineNum + 1; i <= totalLines; i++) {
 508     :         const checkLine = doc.line(i);
 509     :         const checkText = checkLine.text;
 510     : 
 511     :         if (isBlankLine(checkText)) continue;
 512     : 
 513     :         if (getHeaderLevel(checkText) > 0) {
 514     :           return lastContentLine;
 515     :         }
 516     : 
 517     :         const checkIndent = getIndent(checkText);
 518     : 
 519     :         if (checkIndent <= startIndent) {
 520     :           return lastContentLine;
 521     :         }
 522     : 
 523     :         lastContentLine = i;
 524     :       }
 525     : 
 526     :       return lastContentLine;
 527     :     }
 528     : 
 529     :     function findContainingFoldStart(state, lineNum) {
 530     :       const doc = state.doc;
 531     :       const currentLine = doc.line(lineNum);
 532     :       const currentText = currentLine.text;
 533     : 
 534     :       if (canStartFold(currentText) && hasFoldableChildren(doc, lineNum)) {
 535     :         return currentLine.from;
 536     :       }
 537     : 
 538     :       const currentIndent = getIndent(currentText);
 539     : 
 540     :       for (let i = lineNum - 1; i >= 1; i--) {
 541     :         const line = doc.line(i);
 542     :         const text = line.text;
 543     : 
 544     :         if (isBlankLine(text)) continue;
 545     : 
 546     :         const lineIndent = getIndent(text);
 547     :         const headerLevel = getHeaderLevel(text);
 548     : 
 549     :         if (headerLevel > 0) {
 550     :           const foldEnd = findFoldEnd(doc, i);
 551     :           if (foldEnd >= lineNum) {
 552     :             return line.from;
 553     :           }
 554     :           continue;
 555     :         }
 556     : 
 557     :         if (lineIndent < currentIndent && canStartFold(text) && hasFoldableChildren(doc, i)) {
 558     :           const foldEnd = findFoldEnd(doc, i);
 559     :           if (foldEnd >= lineNum) {
 560     :             return line.from;
 561     :           }
 562     :         }
 563     :       }
 564     : 
 565     :       return null;
 566     :     }
 567     : 
 568     :     // Folditall-style fold service
 569     :     const folditallFoldService = foldService.of((state, lineStart, lineEnd) => {
 570     :       const doc = state.doc;
 571     :       const line = doc.lineAt(lineStart);
 572     :       const text = line.text;
 573     :       const lineNum = line.number;
 574     : 
 575     :       if (isBlankLine(text)) return null;
 576     :       if (!canStartFold(text)) return null;
 577     :       if (!hasFoldableChildren(doc, lineNum)) return null;
 578     : 
 579     :       const endLineNum = findFoldEnd(doc, lineNum);
 580     :       if (endLineNum <= lineNum) return null;
 581     : 
 582     :       const endLine = doc.line(endLineNum);
 583     :       return { from: line.to, to: endLine.to };
 584     :     });
 585     : 
 586     :     // Create editor theme
 587     :     const editorTheme = EditorView.theme({
 588     :       '&': {
 589     :         fontSize: '14px',
 590     :         fontFamily: 'var(--theme-font-mono)',
 591     :         backgroundColor: 'var(--base01)',
 592     :         color: 'var(--base05)',
 593     :       },
 594     :       '&.cm-focused': {
 595     :         outline: 'none',
 596     :       },
 597     :       '.cm-content': {
 598     :         padding: '10px 14px',
 599     :         caretColor: 'var(--base05)',
 600     :       },
 601     :       '.cm-cursor, .cm-dropCursor': {
 602     :         borderLeftColor: 'var(--base05)',
 603     :       },
 604     :       '.cm-selectionBackground, ::selection': {
 605     :         backgroundColor: 'var(--base02)',
 606     :       },
 607     :       '.cm-activeLine': {
 608     :         backgroundColor: 'var(--base02)',
 609     :       },
 610     :       '.cm-activeLineGutter': {
 611     :         backgroundColor: 'var(--base02)',
 612     :       },
 613     :       '.cm-gutters': {
 614     :         backgroundColor: 'var(--base01)',
 615     :         color: 'var(--base03)',
 616     :         border: 'none',
 617     :         borderRight: '1px solid var(--base02)',
 618     :       },
 619     :       '.cm-lineNumbers .cm-gutterElement': {
 620     :         padding: '0 8px 0 4px',
 621     :       },
 622     :       '.cm-foldGutter': {
 623     :         width: '12px',
 624     :       },
 625     :       '.cm-header': {
 626     :         color: 'var(--base0D)',
 627     :         fontWeight: '600',
 628     :       },
 629     :       '.cm-fat-cursor': {
 630     :         backgroundColor: 'var(--base05) !important',
 631     :         color: 'var(--base00) !important',
 632     :       },
 633     :       '&:not(.cm-focused) .cm-fat-cursor': {
 634     :         backgroundColor: 'transparent !important',
 635     :         outline: '1px solid var(--base05)',
 636     :       },
 637     :       '.cm-vim-panel': {
 638     :         padding: '4px 10px',
 639     :         backgroundColor: 'var(--base00)',
 640     :         borderTop: '1px solid var(--base02)',
 641     :         fontFamily: 'var(--theme-font-mono)',
 642     :         fontSize: '13px',
 643     :         color: 'var(--base04)',
 644     :       },
 645     :       '.cm-vim-panel input': {
 646     :         backgroundColor: 'transparent',
 647     :         border: 'none',
 648     :         outline: 'none',
 649     :         color: 'var(--base05)',
 650     :         fontFamily: 'inherit',
 651     :         fontSize: 'inherit',
 652     :       },
 653     :     }, { dark: true });
 654     : 
 655     :     // Build extensions
 656     :     const extensions = [
 657     :       history(),
 658     :       drawSelection(),
 659     :       indentOnInput(),
 660     :       bracketMatching(),
 661     :       highlightActiveLine(),
 662     :       highlightActiveLineGutter(),
 663     :       highlightSelectionMatches(),
 664     : 
 665     :       keymap.of([
 666     :         ...defaultKeymap,
 667     :         ...historyKeymap,
 668     :         ...searchKeymap,
 669     :         indentWithTab,
 670     :       ]),
 671     : 
 672     :       markdown({ base: markdownLanguage }),
 673     :       syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
 674     : 
 675     :       // Folding support
 676     :       codeFolding(),
 677     :       folditallFoldService,
 678     :       lineNumbers(),
 679     :       foldGutter(),
 680     : 
 681     :       // Theme
 682     :       editorTheme,
 683     : 
 684     :       // Vim mode (starts disabled)
 685     :       vimCompartment.of([]),
 686     : 
 687     :       // Update listener for status
 688     :       EditorView.updateListener.of(update => {
 689     :         if (update.selectionSet) {
 690     :           const pos = update.state.selection.main.head;
 691     :           const line = update.state.doc.lineAt(pos);
 692     :           const col = pos - line.from + 1;
 693     :           document.getElementById('cursor-pos').textContent =
 694     :             `Cursor: ${line.number}:${col}`;
 695     : 
 696     :           // Update vim status line position
 697     :           const posInfo = document.querySelector('.vim-position-info');
 698     :           if (posInfo) {
 699     :             posInfo.textContent = `Ln ${line.number}, Col ${col}`;
 700     :           }
 701     :         }
 702     : 
 703     :         // Check for vim mode changes
 704     :         const statusLine = document.getElementById('vim-status-line');
 705     :         if (statusLine && statusLine.style.display !== 'none') {
 706     :           try {
 707     :             const cm = getCM(update.view);
 708     :             if (cm && cm.state && cm.state.vim) {
 709     :               const vimState = cm.state.vim;
 710     :               let currentMode = 'normal';
 711     :               let modeLabel = 'NORMAL';
 712     :               let modeColor = 'var(--base0A)';
 713     : 
 714     :               if (vimState.insertMode) {
 715     :                 currentMode = 'insert';
 716     :                 modeLabel = '-- INSERT --';
 717     :                 modeColor = 'var(--base0B)';
 718     :               } else if (vimState.visualMode) {
 719     :                 if (vimState.visualLine) {
 720     :                   currentMode = 'visual-line';
 721     :                   modeLabel = '-- V-LINE --';
 722     :                 } else if (vimState.visualBlock) {
 723     :                   currentMode = 'visual-block';
 724     :                   modeLabel = '-- V-BLOCK --';
 725     :                 } else {
 726     :                   currentMode = 'visual';
 727     :                   modeLabel = '-- VISUAL --';
 728     :                 }
 729     :                 modeColor = 'var(--base0E)';
 730     :               }
 731     : 
 732     :               const modeIndicator = document.querySelector('.vim-mode-indicator');
 733     :               if (modeIndicator) {
 734     :                 modeIndicator.textContent = modeLabel;
 735     :                 modeIndicator.style.color = modeColor;
 736     :               }
 737     :             }
 738     :           } catch (e) {
 739     :             // Vim not active
 740     :           }
 741     :         }
 742     :       }),
 743     :     ];
 744     : 
 745     :     // Create editor
 746     :     const state = EditorState.create({
 747     :       doc: TEST_CONTENT,
 748     :       extensions,
 749     :     });
 750     : 
 751     :     const view = new EditorView({
 752     :       state,
 753     :       parent: document.getElementById('editor-container'),
 754     :     });
 755     : 
 756     :     // Expose for testing
 757     :     window.editorView = view;
 758     :     window.editorState = state;
 759     :     window.foldAll = () => foldAll(view);
 760     :     window.unfoldAll = () => unfoldAll(view);
 761     : 
 762     :     // Folditall-aware foldCode: folds the containing fold region
 763     :     window.foldCode = (pos) => {
 764     :       const lineNum = view.state.doc.lineAt(pos).number;
 765     :       const foldStart = findContainingFoldStart(view.state, lineNum);
 766     :       if (foldStart !== null) {
 767     :         const foldRange = foldable(view.state, foldStart, foldStart);
 768     :         if (foldRange) {
 769     :           view.dispatch({
 770     :             effects: foldEffect.of({ from: foldRange.from, to: foldRange.to })
 771     :           });
 772     :           return true;
 773     :         }
 774     :       }
 775     :       return false;
 776     :     };
 777     : 
 778     :     // Folditall-aware unfoldCode
 779     :     window.unfoldCode = (pos) => {
 780     :       const line = view.state.doc.lineAt(pos);
 781     :       const lineNum = line.number;
 782     : 
 783     :       // Check if cursor is in a folded range
 784     :       const foldedRange = findFoldedRangeAt(view.state, pos);
 785     :       if (foldedRange) {
 786     :         view.dispatch({
 787     :           effects: unfoldEffect.of({ from: foldedRange.from, to: foldedRange.to })
 788     :         });
 789     :         return true;
 790     :       }
 791     : 
 792     :       // Check if there's a fold starting at the end of current line
 793     :       const foldAtLineEnd = findFoldedRangeAt(view.state, line.to);
 794     :       if (foldAtLineEnd) {
 795     :         view.dispatch({
 796     :           effects: unfoldEffect.of({ from: foldAtLineEnd.from, to: foldAtLineEnd.to })
 797     :         });
 798     :         return true;
 799     :       }
 800     : 
 801     :       const foldStart = findContainingFoldStart(view.state, lineNum);
 802     :       if (foldStart !== null) {
 803     :         const foldStartLine = view.state.doc.lineAt(foldStart);
 804     :         const foldRange = foldable(view.state, foldStartLine.from, foldStartLine.to);
 805     :         if (foldRange) {
 806     :           const folded = foldedRanges(view.state);
 807     :           let isFolded = false;
 808     :           folded.between(foldRange.from, foldRange.to, (from) => {
 809     :             if (from === foldRange.from) isFolded = true;
 810     :           });
 811     :           if (isFolded) {
 812     :             view.dispatch({
 813     :               effects: unfoldEffect.of({ from: foldRange.from, to: foldRange.to })
 814     :             });
 815     :             return true;
 816     :           }
 817     :         }
 818     :       }
 819     :       return false;
 820     :     };
 821     : 
 822     :     window.foldable = (pos) => foldable(view.state, pos, pos);
 823     : 
 824     :     window.setVimMode = (enabled) => {
 825     :       view.dispatch({
 826     :         effects: vimCompartment.reconfigure(enabled ? vim() : []),
 827     :       });
 828     : 
 829     :       // Show/hide vim status line
 830     :       const statusLine = document.getElementById('vim-status-line');
 831     :       if (statusLine) {
 832     :         statusLine.style.display = enabled ? 'flex' : 'none';
 833     :         if (enabled) {
 834     :           const modeIndicator = document.querySelector('.vim-mode-indicator');
 835     :           if (modeIndicator) {
 836     :             modeIndicator.textContent = 'NORMAL';
 837     :             modeIndicator.style.color = 'var(--base0A)';
 838     :           }
 839     :         }
 840     :       }
 841     :     };
 842     : 
 843     :     window.getCursorLine = () => {
 844     :       const pos = view.state.selection.main.head;
 845     :       return view.state.doc.lineAt(pos).number;
 846     :     };
 847     : 
 848     :     window.setCursorLine = (lineNum) => {
 849     :       const line = view.state.doc.line(lineNum);
 850     :       view.dispatch({
 851     :         selection: { anchor: line.from },
 852     :         scrollIntoView: true,
 853     :       });
 854     :       view.focus();
 855     :     };
 856     : 
 857     :     window.getFoldedRanges = () => {
 858     :       // Get all folded ranges from the fold state
 859     :       const foldState = view.state.field(codeFolding().spec.provides, false);
 860     :       if (!foldState) return [];
 861     :       // Note: This is a simplified check - full implementation would iterate decorations
 862     :       return [];
 863     :     };
 864     : 
 865     :     window.isFolded = (lineNum) => {
 866     :       const line = view.state.doc.line(lineNum);
 867     :       // Check if the line is at a fold point and is currently folded
 868     :       const foldRange = foldable(view.state, line.from, line.to);
 869     :       if (!foldRange) return false;
 870     : 
 871     :       // Check the fold decorations
 872     :       // A line is considered folded if the next visible line is not lineNum + 1
 873     :       // This is a heuristic - better would be to check fold state directly
 874     :       return false; // Placeholder - actual implementation needs fold state access
 875     :     };
 876     : 
 877     :     window.simulateVimCommand = (keys) => {
 878     :       // Simulate vim keystrokes
 879     :       view.focus();
 880     :       for (const key of keys) {
 881     :         const event = new KeyboardEvent('keydown', {
 882     :           key: key,
 883     :           code: `Key${key.toUpperCase()}`,
 884     :           bubbles: true,
 885     :           cancelable: true,
 886     :         });
 887     :         view.contentDOM.dispatchEvent(event);
 888     :       }
 889     :     };
 890     : 
 891     :     // UI Controls
 892     :     document.getElementById('vim-toggle').addEventListener('change', (e) => {
 893     :       window.setVimMode(e.target.checked);
 894     :     });
 895     : 
 896     :     document.getElementById('fold-all').addEventListener('click', () => {
 897     :       window.foldAll();
 898     :     });
 899     : 
 900     :     document.getElementById('unfold-all').addEventListener('click', () => {
 901     :       window.unfoldAll();
 902     :     });
 903     : 
 904     :     // Signal ready
 905     :     document.body.dataset.ready = 'true';
 906     :     console.log('[test] Editor ready');
 907     :   </script>
 908     : </body>
 909     : </html>
Modified regular file tests/fixtures/desktop-app.ts:
    ...
 198  198:   });
 199  199: 
 200  200:   // Wait for background window to be ready (API loaded)
 201  201:   // Use 30s timeout to handle slow launches after previous test cleanup
 202  201:   const bgWindow = await waitForWindowHelper(() => electronApp.windows(), 'app/background.html', 30000);
 203  201:   await waitForAppReady(bgWindow, 15000);
      202:   await waitForAppReady(bgWindow, 10000);
 204  203: 
 205  204:   // Hybrid mode: wait for extension host (built-in) AND separate windows (external like 'example')
 206  205:   const waitForHybridExtensions = async (timeout: number): Promise<void> => {
    ...
 337  336:       if (isRunning(pid)) {
 338  337:         console.error(`[test] WARNING: Process ${pid} still running after SIGKILL`);
 339  338:       }
 340     : 
 341     :       // Allow extra time for OS to fully release resources (ports, files, etc.)
 342     :       await sleep(500);
 343  339:     }
 344  340:   };
 345  341: }
    ...