nsa-sheets-db-builder 0.0.1-alpha.2 → 0.0.1-alpha.3

package/bin/sheets-deployer.mjs

@@ -9,6 +9,7 @@
  *
  * Commands:
  *   init             Initialize a new DB project from a template
+ *   gen              Generate app source files (config, schema, router, main)
  *   build            Build GAS output for a DB project
  *   push             Build + push to Google Apps Script
  *   deploy           Build + push + deploy
@@ -48,6 +49,7 @@ const scriptsDir = path.resolve(__dirname, '..', 'scripts');
 // Command → script mapping
 const COMMANDS = {
   'init':            'init.mjs',
+  'gen':             'gen.mjs',
   'build':           'build.mjs',
   'push':            ['build.mjs', '--push'],
   'deploy':          ['build.mjs', '--push', '--deploy'],
@@ -74,7 +76,7 @@ const command = process.argv[2];
 const restArgs = process.argv.slice(3);
 
 if (!command || command === '--help' || command === '-h') {
-  console.log('nsa-sheets-db-builder v0.0.1-alpha.2 — Google Sheets database provisioner\n');
+  console.log('nsa-sheets-db-builder v0.0.1-alpha.3 — Google Sheets database provisioner\n');
   console.log('Usage: nsa-sheets-db-builder <command> [options]\n');
   console.log('Commands:');
   const maxLen = Math.max(...Object.keys(COMMANDS).map(k => k.length));
@@ -145,6 +147,7 @@ try {
 function getDescription(cmd) {
   const descriptions = {
     'init': 'Initialize a new DB project from a template',
+    'gen': 'Generate app source files (config, schema, router, main)',
     'build': 'Build GAS output for a DB project (all instances)',
     'push': 'Build + push instance to Google Apps Script',
     'deploy': 'Build + push + deploy instance',

package/libs/common/uuid.ts

@@ -0,0 +1,17 @@
+// UUID utility class for ID generation and hashing
+class UUID {
+  static generate(input?: string): string {
+    if (input) {
+      const raw = Utilities.computeDigest(Utilities.DigestAlgorithm.SHA_256, input);
+      const hex = raw.map((b: number) => ('0' + ((b + 256) % 256).toString(16)).slice(-2)).join('');
+      return hex.substring(0, 8) + '-' + hex.substring(8, 12) + '-4' + hex.substring(13, 16) + '-' + hex.substring(16, 20) + '-' + hex.substring(20, 32);
+    }
+    return Utilities.getUuid();
+  }
+}
+
+class pdUUIDStatic {
+  static generate(input?: string): string {
+    return UUID.generate(input);
+  }
+}

package/libs/db_ddl.ts

@@ -23,7 +23,7 @@ declare class GASLoggerV2 {
 // ── Constants ─────────────────────────────
 
 const DDL_SYS_TABLES_SHEET = '__sys__tables__';
-const DDL_SYS_TABLES_HEADERS = ['table_name', 'sheet_name', 'spreadsheet_id', 'created_at', 'column_count'];
+const DDL_SYS_TABLES_HEADERS = ['id', 'table_name', 'spreadsheet_id', 'counter', 'last_update', 'last_update_hash', '__audit', '__archived'];
 
 // ── Types ─────────────────────────────────
 
@@ -35,7 +35,6 @@ interface DDLCreateSpreadsheetResult {
 
 interface DDLTableResult {
   name: string;
-  sheetName: string;
   spreadsheetId: string;
   status: 'created' | 'exists' | 'skipped';
   columns?: number;
@@ -59,9 +58,9 @@ interface DDLDescribeResult {
 }
 
 interface DDLSyncResult {
-  created: { name: string; sheetName: string; columns: number }[];
-  existing: { name: string; sheetName: string }[];
-  drift: { name: string; sheetName: string; missing: string[]; extra: string[] }[];
+  created: { name: string; spreadsheetId: string; columns: number }[];
+  existing: { name: string; spreadsheetId: string }[];
+  drift: { name: string; spreadsheetId: string; missing: string[]; extra: string[] }[];
 }
 
 // ── Core DDL Class ────────────────────────
@@ -99,6 +98,59 @@ class DBDDLV2 {
    * Provision tables from a DBConfigV2-shaped tables object.
    * Creates sheets with headers + __sys__tables__ entries for each table.
    */
+  /**
+   * Provision a single table as its own spreadsheet inside the given folder.
+   * Spreadsheet name: project_name__table_name__env_name
+   * Sheet name inside = tableName
+   */
+  provisionTable(
+    systemSs: GoogleAppsScript.Spreadsheet.Spreadsheet,
+    folder: GoogleAppsScript.Drive.Folder,
+    projectName: string,
+    envName: string,
+    tableName: string,
+    schema: Record<string, any>
+  ): DDLTableResult {
+    const headers = Object.keys(schema);
+
+    // Spreadsheet name: project_name__table_name__env_name
+    const spreadsheetName = `${projectName}__${tableName}__${envName}`;
+    const ss = SpreadsheetApp.create(spreadsheetName);
+    const spreadsheetId = ss.getId();
+
+    // Move into the Drive folder
+    const file = DriveApp.getFileById(spreadsheetId);
+    folder.addFile(file);
+    DriveApp.getRootFolder().removeFile(file);
+
+    // Rename default Sheet1 to tableName
+    const sheet = ss.getSheets()[0];
+    sheet.setName(tableName);
+    sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
+    sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
+
+    // Trim extra columns (default 26 → schema column count)
+    const maxCols = sheet.getMaxColumns();
+    if (maxCols > headers.length) {
+      sheet.deleteColumns(headers.length + 1, maxCols - headers.length);
+    }
+
+    // Trim extra rows (default 1000 → just the header row)
+    const maxRows = sheet.getMaxRows();
+    if (maxRows > 1) {
+      sheet.deleteRows(2, maxRows - 1);
+    }
+
+    // Register in __sys__tables__ on the system spreadsheet
+    this.registerInSysTables(systemSs, tableName, spreadsheetId);
+
+    this.logger?.info('DBDDLV2.provisionTable', `Created spreadsheet "${tableName}" with ${headers.length} columns`, { spreadsheetId });
+    return { name: tableName, spreadsheetId, status: 'created', columns: headers.length };
+  }
+
+  /**
+   * Provision tables from a DBConfigV2-shaped tables object (legacy — all in one spreadsheet).
+   */
   provisionTables(spreadsheetId: string, tables: Record<string, any>): DDLProvisionResult {
     if (!spreadsheetId) throw new Error('Missing "spreadsheetId" parameter');
     if (!tables || typeof tables !== 'object') throw new Error('Missing or invalid "tables" parameter');
@@ -109,34 +161,40 @@ class DBDDLV2 {
     const results: DDLTableResult[] = [];
 
     for (const [tableName, tableConfig] of Object.entries(tables)) {
-      const sheetName = tableConfig.sheetName || tableName;
       const schema = tableConfig.schema;
 
       if (!schema) {
         this.logger?.warn('DBDDLV2.provisionTables', `Table "${tableName}" has no schema, skipping`, {});
-        results.push({ name: tableName, sheetName, spreadsheetId, status: 'skipped', reason: 'no schema' });
+        results.push({ name: tableName, spreadsheetId, status: 'skipped', reason: 'no schema' });
         continue;
       }
 
-      let sheet = ss.getSheetByName(sheetName);
+      let sheet = ss.getSheetByName(tableName);
       if (sheet) {
-        this.logger?.info('DBDDLV2.provisionTables', `Sheet "${sheetName}" already exists, skipping`, {});
-        results.push({ name: tableName, sheetName, spreadsheetId, status: 'exists' });
+        this.logger?.info('DBDDLV2.provisionTables', `Sheet "${tableName}" already exists, skipping`, {});
+        results.push({ name: tableName, spreadsheetId, status: 'exists' });
         continue;
       }
 
-      // Create sheet with headers
-      sheet = ss.insertSheet(sheetName);
+      sheet = ss.insertSheet(tableName);
       const headers = Object.keys(schema);
       sheet.getRange(1, 1, 1, headers.length).setValues([headers]);
       sheet.getRange(1, 1, 1, headers.length).setFontWeight('bold');
-      sheet.setFrozenRows(1);
+  
+      const maxCols = sheet.getMaxColumns();
+      if (maxCols > headers.length) {
+        sheet.deleteColumns(headers.length + 1, maxCols - headers.length);
+      }
 
-      // Register in __sys__tables__
-      this.registerInSysTables(ss, tableName, sheetName, spreadsheetId, headers.length);
+      const maxRows = sheet.getMaxRows();
+      if (maxRows > 1) {
+        sheet.deleteRows(2, maxRows - 1);
+      }
 
-      this.logger?.info('DBDDLV2.provisionTables', `Created sheet "${sheetName}" with ${headers.length} columns`, {});
-      results.push({ name: tableName, sheetName, spreadsheetId, status: 'created', columns: headers.length });
+      this.registerInSysTables(ss, tableName, spreadsheetId);
+
+      this.logger?.info('DBDDLV2.provisionTables', `Created sheet "${tableName}" with ${headers.length} columns`, {});
+      results.push({ name: tableName, spreadsheetId, status: 'created', columns: headers.length });
     }
 
     return { tables: results };
@@ -227,22 +285,28 @@ class DBDDLV2 {
     const drift: DDLSyncResult['drift'] = [];
 
     for (const [tableName, tableConfig] of Object.entries(tables)) {
-      const sheetName = tableConfig.sheetName || tableName;
       const schema = tableConfig.schema;
       if (!schema) continue;
 
       const expectedHeaders = Object.keys(schema);
-      const sheet = ss.getSheetByName(sheetName);
+      const sheet = ss.getSheetByName(tableName);
 
       if (!sheet) {
-        // Create missing sheet
-        const newSheet = ss.insertSheet(sheetName);
+        // Create missing sheet — trim to exact schema size
+        const newSheet = ss.insertSheet(tableName);
         newSheet.getRange(1, 1, 1, expectedHeaders.length).setValues([expectedHeaders]);
         newSheet.getRange(1, 1, 1, expectedHeaders.length).setFontWeight('bold');
-        newSheet.setFrozenRows(1);
-        this.registerInSysTables(ss, tableName, sheetName, spreadsheetId, expectedHeaders.length);
-
-        created.push({ name: tableName, sheetName, columns: expectedHeaders.length });
+        const syncMaxCols = newSheet.getMaxColumns();
+        if (syncMaxCols > expectedHeaders.length) {
+          newSheet.deleteColumns(expectedHeaders.length + 1, syncMaxCols - expectedHeaders.length);
+        }
+        const syncMaxRows = newSheet.getMaxRows();
+        if (syncMaxRows > 1) {
+          newSheet.deleteRows(2, syncMaxRows - 1);
+        }
+        this.registerInSysTables(ss, tableName, spreadsheetId);
+
+        created.push({ name: tableName, spreadsheetId, columns: expectedHeaders.length });
         continue;
       }
 
@@ -256,9 +320,9 @@ class DBDDLV2 {
       const extra = actualHeaders.filter(h => !expectedHeaders.includes(h));
 
       if (missing.length > 0 || extra.length > 0) {
-        drift.push({ name: tableName, sheetName, missing, extra });
+        drift.push({ name: tableName, spreadsheetId, missing, extra });
       } else {
-        existing.push({ name: tableName, sheetName });
+        existing.push({ name: tableName, spreadsheetId });
       }
     }
 
@@ -267,31 +331,40 @@ class DBDDLV2 {
 
   // ── Internal helpers ──────────────────────
 
-  private ensureSysTablesSheet(ss: GoogleAppsScript.Spreadsheet.Spreadsheet): GoogleAppsScript.Spreadsheet.Sheet {
+  ensureSysTablesSheet(ss: GoogleAppsScript.Spreadsheet.Spreadsheet): GoogleAppsScript.Spreadsheet.Sheet {
     let sheet = ss.getSheetByName(DDL_SYS_TABLES_SHEET);
     if (sheet) return sheet;
 
     sheet = ss.insertSheet(DDL_SYS_TABLES_SHEET);
     sheet.getRange(1, 1, 1, DDL_SYS_TABLES_HEADERS.length).setValues([DDL_SYS_TABLES_HEADERS]);
     sheet.getRange(1, 1, 1, DDL_SYS_TABLES_HEADERS.length).setFontWeight('bold');
-    sheet.setFrozenRows(1);
+
+    // Trim to exact size
+    const sysCols = sheet.getMaxColumns();
+    if (sysCols > DDL_SYS_TABLES_HEADERS.length) {
+      sheet.deleteColumns(DDL_SYS_TABLES_HEADERS.length + 1, sysCols - DDL_SYS_TABLES_HEADERS.length);
+    }
+    const sysRows = sheet.getMaxRows();
+    if (sysRows > 1) {
+      sheet.deleteRows(2, sysRows - 1);
+    }
 
     this.logger?.info('DBDDLV2.ensureSysTablesSheet', 'Created __sys__tables__ metadata sheet', {});
 
     return sheet;
   }
 
-  private registerInSysTables(
+  registerInSysTables(
     ss: GoogleAppsScript.Spreadsheet.Spreadsheet,
     tableName: string,
-    sheetName: string,
-    spreadsheetId: string,
-    columnCount: number
+    spreadsheetId: string
   ): void {
     const sysSheet = ss.getSheetByName(DDL_SYS_TABLES_SHEET);
     if (!sysSheet) return;
 
-    const row = [tableName, sheetName, spreadsheetId, new Date().toISOString(), columnCount];
+    const id = Utilities.getUuid();
+    // Columns: id, table_name, spreadsheet_id, counter, last_update, last_update_hash, __audit, __archived
+    const row = [id, tableName, spreadsheetId, 0, '', '', '', false];
     sysSheet.appendRow(row);
 
     this.logger?.info('DBDDLV2.registerInSysTables', `Registered "${tableName}" in __sys__tables__`, {});
@@ -306,7 +379,7 @@ class DBDDLV2 {
 
     const data = sysSheet.getDataRange().getValues();
     for (let i = data.length - 1; i >= 1; i--) {
-      if (data[i][0] === tableName) {
+      if (data[i][1] === tableName) { // column B = table_name
         sysSheet.deleteRow(i + 1);
         this.logger?.info('DBDDLV2.unregisterFromSysTables', `Removed "${tableName}" from __sys__tables__`, {});
         return;

package/libs/libraries.json

@@ -35,6 +35,15 @@
       "dependsOn": [],
       "source": "common"
     },
+    "uuid": {
+      "file": "uuid.ts",
+      "description": "UUID generation and hashing utility",
+      "version": "1.0.0",
+      "order": 3,
+      "required": true,
+      "dependsOn": [],
+      "source": "common"
+    },
     "db_ddl": {
       "file": "db_ddl.ts",
       "description": "Schema provisioning (DDL) for Google Sheets databases",

package/libs/spreadsheets_db.ts

@@ -14,12 +14,11 @@ const SYSTEM_TABLES: { [tableName: string]: Partial<TableConfig> } = {
       id: { type: 'string', primaryKey: true, required: true },
       table_name: { type: 'string', required: true },
       spreadsheet_id: { type: 'string', required: true },
-      sheet_name: { type: 'string', required: true },
       counter: { type: 'number', defaultValue: 0 },
       last_update: { type: 'datetime' },
       last_update_hash: { type: 'string' },
-      __audit__: { type: 'object' },
-      __archived__: { type: 'boolean', defaultValue: false }
+      __audit: { type: 'object' },
+      __archived: { type: 'boolean', defaultValue: false }
     },
     idGenerator: 'STATIC_UUID',
     readOnly: false,
@@ -140,7 +139,6 @@ interface CachedUser {
 interface TableRuntimeState {
   tableName: string;
   spreadsheetId: string;
-  sheetName: string;
   counter: number;
   lastUpdate: number; // Unix timestamp in milliseconds
   lastUpdateHash: string;
@@ -149,17 +147,10 @@ interface TableRuntimeState {
 interface TableMetadataRow {
   table_name: string;
   spreadsheet_id: string;
-  sheet_name: string;
-  schema: string; // JSON stringified
   counter: number;
   last_update: string;
   last_update_hash: string;
-  id_generator: string;
-  read_only: boolean;
-  delete_mode: string;
-  created_at: string;
-  updated_at: string;
-  __archived__: boolean;
+  __archived: boolean;
 }
 
 interface EntityLock {
@@ -232,8 +223,8 @@ class TableV2 {
     db: DBV2 | null = null
   ) {
     this.tableName = tableName;
-    this.spreadsheetId = tableConfig.spreadsheetId;
-    this.sheetName = tableConfig.sheetName;
+    this.spreadsheetId = runtimeState?.spreadsheetId || tableConfig.spreadsheetId;
+    this.sheetName = tableConfig.sheetName || tableName;
     this.schema = tableConfig.schema;
     this.runtimeState = runtimeState;
     this.metadataSpreadsheetId = metadataSpreadsheetId;
@@ -263,7 +254,7 @@ class TableV2 {
   }
 
   private hasAuditField(): boolean {
-    return '__audit__' in this.schema;
+    return '__audit' in this.schema;
   }
 
   private createAuditData(operation: 'create' | 'update', oldData?: any, newData?: any): AuditData {
@@ -361,7 +352,7 @@ class TableV2 {
   private getLastRow(): number {
     try {
       const sheet = this.getSheet();
-      return sheet.getMaxRows();
+      return sheet.getLastRow();
     } catch (error) {
       GASErrorV2.handleError(
         error,
@@ -536,6 +527,14 @@ class TableV2 {
     }
   }
 
+  list(options: any = {}): any {
+    return this.getData(options.pageStart || 0, options.pageSize || 0);
+  }
+
+  get(id: string): any {
+    return this.getById(id);
+  }
+
   getById(id: string): any {
     try {
       this.initializeTableDetails();
@@ -676,7 +675,7 @@ class TableV2 {
       for (const [columnName, columnDef] of Object.entries(this.schema)) {
         if (columnName === this.primaryKey) {
           newRow[index] = typedId.toString();
-        } else if (columnName === '__audit__') {
+        } else if (columnName === '__audit') {
           // Inject audit data
           newRow[index] = auditData ? JSON.stringify(auditData) : '';
         } else if (entry.hasOwnProperty(columnName)) {
@@ -695,7 +694,7 @@ class TableV2 {
           newRow[index] = formatDateTime();
         } else if (columnName === '__last_updated_by__') {
           newRow[index] = Session.getActiveUser().getEmail();
-        } else if (columnName === '__archived__') {
+        } else if (columnName === '__archived') {
           newRow[index] = entry[columnName] !== undefined ? entry[columnName] : false;
         } else if (columnDef.defaultValue !== undefined) {
           newRow[index] = columnDef.defaultValue;
@@ -803,7 +802,7 @@ class TableV2 {
       const hasAudit = this.hasAuditField();
       let existingAuditData: AuditData | null = null;
       if (hasAudit) {
-        const auditIndex = Object.keys(this.schema).indexOf('__audit__');
+        const auditIndex = Object.keys(this.schema).indexOf('__audit');
         try {
           existingAuditData = JSON.parse(rowData[auditIndex]) as AuditData;
         } catch {
@@ -814,7 +813,7 @@ class TableV2 {
       // Update the row with new data
       let index = 0;
       for (const [columnName, columnDef] of Object.entries(this.schema)) {
-        if (columnName === '__audit__') {
+        if (columnName === '__audit') {
           // Update audit data
           const newAuditData = this.createAuditData('update', existingAuditData, data);
           rowData[index] = JSON.stringify(newAuditData);
@@ -932,9 +931,9 @@ class TableV2 {
 
   private softDelete(id: any): any {
     try {
-      if (!this.schema.hasOwnProperty('__archived__')) {
+      if (!this.schema.hasOwnProperty('__archived')) {
         throw new GASErrorV2(
-          `Soft delete not possible, "__archived__" field not found in schema`,
+          `Soft delete not possible, "__archived" field not found in schema`,
           'TableV2.softDelete',
           {}, this.logger?.getTraceId()
         );
@@ -946,7 +945,7 @@ class TableV2 {
       }
 
       const sheet = this.getSheet();
-      const archivedColumnIndex = Object.keys(this.schema).indexOf('__archived__');
+      const archivedColumnIndex = Object.keys(this.schema).indexOf('__archived');
       sheet.getRange(rowIndex, archivedColumnIndex + 1).setValue(true);
       this.updateLastTableUpdateInfo(formatDateTime(), { id, method: 'softDelete' });
       this.logger?.info('TableV2.softDelete', `Soft deleted row with ID '${id}' in table ${this.tableName}`, {});
@@ -1015,12 +1014,12 @@ class TableV2 {
         throw new Error(`Table '${this.tableName}' not found in __sys__tables__`);
       }
 
-      // Column 5 is counter, read-increment-write atomically
-      const currentCounter = sysTablesSheet.getRange(rowIndex, 5).getValue();
+      // Column 4 is counter (id=1, table_name=2, spreadsheet_id=3, counter=4)
+      const currentCounter = sysTablesSheet.getRange(rowIndex, 4).getValue();
       this.logger?.debug('TableV2.updateCounter', 'Read current counter value', { tableName: this.tableName, currentCounter, rowIndex });
       const newCounter = Number(currentCounter) + 1;
       this.logger?.debug('TableV2.updateCounter', 'Calculated new counter', { tableName: this.tableName, newCounter });
-      sysTablesSheet.getRange(rowIndex, 5).setValue(newCounter);
+      sysTablesSheet.getRange(rowIndex, 4).setValue(newCounter);
 
       // Update in-memory counter
       this.counter = newCounter;
@@ -1114,8 +1113,8 @@ class TableV2 {
             }
 
             // Debug logging for boolean conversion
-            if (columnName === '__archived__' && this.tableName === 'epuap_tickets') {
-              this.logger?.debug('TableV2.toArrayOfObjects', `Boolean conversion for __archived__`, {
+            if (columnName === '__archived' && this.tableName === 'epuap_tickets') {
+              this.logger?.debug('TableV2.toArrayOfObjects', `Boolean conversion for __archived`, {
                 originalValue: row[index],
                 originalType: typeof row[index],
                 convertedValue: value,
@@ -1607,6 +1606,18 @@ class DBV2 {
     this.initializeSystemCaches();
   }
 
+  /**
+   * Get a table instance by name. Initializes lazily from __sys__tables__ runtime state.
+   */
+  table(tableName: string): TableV2 | null {
+    try {
+      this.initializeTable(tableName);
+      return this.tables.get(tableName) || null;
+    } catch {
+      return null;
+    }
+  }
+
   // ========================================
   // Two-Level Locking Mechanism
   // ========================================
@@ -1943,8 +1954,7 @@ class DBV2 {
       if (dataRecords.length === 0) {
         this.logger?.info('DBV2.cacheSystemTable', `Cached empty table '${tableName}' (0 records) - table exists but has no data`, {
           cacheKey: cacheKey,
-          spreadsheetId: runtimeState.spreadsheetId,
-          sheetName: runtimeState.sheetName
+          spreadsheetId: runtimeState.spreadsheetId
         });
       } else {
         this.logger?.info('DBV2.cacheSystemTable', `Cached ${dataRecords.length} records from '${tableName}'`, {
@@ -1991,7 +2001,7 @@ class DBV2 {
 
     // Build mapping: role -> array of user emails
     for (const user of users) {
-      if (user.__archived__ === false && user.active !== false && user.email) {
+      if (user.__archived === false && user.active !== false && user.email) {
         const role = user.role;
         if (!roleUsers[role]) {
           roleUsers[role] = [];
@@ -2406,12 +2416,12 @@ class DBV2 {
         return;
       }
 
-      // Read runtime state only (9 columns: id, table_name, spreadsheet_id, sheet_name, counter, last_update, last_update_hash, __audit__, __archived__)
-      const data = metadataSheet.getRange(2, 1, lastRow - 1, 9).getValues();
+      // Read runtime state (8 columns: id, table_name, spreadsheet_id, counter, last_update, last_update_hash, __audit, __archived)
+      const data = metadataSheet.getRange(2, 1, lastRow - 1, 8).getValues();
       const runtimeStates: TableRuntimeState[] = [];
 
       for (const row of data) {
-        const archived = row[8]; // __archived__ column (9th column, index 8)
+        const archived = row[7]; // __archived column (8th column, index 7)
         if (archived) {
           continue; // Skip archived tables
         }
@@ -2419,10 +2429,9 @@ class DBV2 {
         const state: TableRuntimeState = {
           tableName: row[1],         // table_name
           spreadsheetId: row[2],     // spreadsheet_id
-          sheetName: row[3],         // sheet_name
-          counter: row[4],           // counter
-          lastUpdate: row[5],        // last_update
-          lastUpdateHash: row[6]     // last_update_hash
+          counter: row[3],           // counter
+          lastUpdate: row[4],        // last_update
+          lastUpdateHash: row[5]     // last_update_hash
         };
 
         runtimeStates.push(state);
@@ -2538,7 +2547,7 @@ class DBV2 {
       }
 
       const now = new Date().getTime(); // Unix timestamp in milliseconds
-      const currentCounter = metadataSheet.getRange(rowIndex, 5).getValue(); // Column E: counter (read only, don't modify)
+      const currentCounter = metadataSheet.getRange(rowIndex, 4).getValue(); // Column D: counter (read only, don't modify)
 
       // Calculate new hash
       const runtimeState = this.getRuntimeState(tableName);
@@ -2547,15 +2556,14 @@ class DBV2 {
         JSON.stringify({
           tableName: tableName,
           spreadsheetId: runtimeState?.spreadsheetId,
-          sheetName: runtimeState?.sheetName,
-          counter: currentCounter, // Use current counter value, don't increment
+          counter: currentCounter,
           last_update: now
         })
       ).map(byte => (byte < 0 ? byte + 256 : byte).toString(16).padStart(2, '0')).join('');
 
       // Update: last_update, last_update_hash (counter updated separately by TableV2.updateCounter)
-      metadataSheet.getRange(rowIndex, 6).setValue(now); // Column F: last_update (Unix timestamp)
-      metadataSheet.getRange(rowIndex, 7).setValue(newHash); // Column G: last_update_hash
+      metadataSheet.getRange(rowIndex, 5).setValue(now); // Column E: last_update (Unix timestamp)
+      metadataSheet.getRange(rowIndex, 6).setValue(newHash); // Column F: last_update_hash
 
       this.logger?.debug('DBV2.updateRuntimeState', `Updated runtime state for ${tableName}`, {
         rowIndex,
@@ -2612,9 +2620,8 @@ class DBV2 {
       const configTable = this.config.tables[state.tableName];
 
       if (configTable) {
-        // Table exists in config - update with runtime location if needed
+        // Table exists in config - update with runtime spreadsheetId from __sys__tables__
         configTable.spreadsheetId = state.spreadsheetId;
-        configTable.sheetName = state.sheetName;
         this.logger?.debug('DBV2.loadTablesFromMetadata', `Merged runtime state for table: ${state.tableName}`);
       } else {
         // Table exists in runtime but not in config - warn but don't create
@@ -2831,8 +2838,8 @@ class DBV2 {
         return filtered as T;
       }
 
-      // Fallback: exclude __audit__ and __archived__ for non-superadmin if no readFields specified
-      const defaultExclude = ['__audit__', '__archived__'];
+      // Fallback: exclude __audit and __archived for non-superadmin if no readFields specified
+      const defaultExclude = ['__audit', '__archived'];
       for (const key in record) {
         if (!defaultExclude.includes(key)) {
           filtered[key] = record[key];

package/libs/triggers.ts

@@ -80,7 +80,7 @@ function rebuildSearchIndex(): void {
 
       if (textFields.length === 0) continue;
 
-      const result = table.list({ filters: { __archived__: false } });
+      const result = table.list({ filters: { __archived: false } });
       const rows = result?.data || [];
 
       for (const row of rows) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nsa-sheets-db-builder",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.1-alpha.3",
   "description": "DDL provisioner for Google Sheets — creates spreadsheets, sheets, and headers",
   "type": "module",
   "license": "MIT",