Address Codex review: .schema indexes/triggers, dump REAL literals

- .schema TABLE now includes the table's indexes/triggers (tbl_name match),
  matching the .dump fix.
- .dump renders non-finite REALs as restorable literals (9e999 / -9e999;
  NaN -> NULL) instead of "inf", which SQLite would parse as an identifier.
- Document two known limitations: .dump isn't FK-dependency-ordered (and
  foreign_keys can't be toggled in the sandbox), and ALTER TABLE RENAME into
  the reserved _audit namespace isn't caught (SQLite doesn't expose the new
  name to the authorizer; low severity since the audit trail is external).

https://claude.ai/code/session_01AdvNtQ7wCMVy8etacVQbjg

Author: claude

Sources/SwiftSQLiteBash/DotCommands.swift

@@ -53,7 +53,10 @@ enum DotCommandRunner {
             var sql = "SELECT sql FROM sqlite_schema WHERE sql IS NOT NULL "
                 + "AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\'"
             if let name = args.first {
-                sql += " AND name='\(escapeSQLString(name))'"
+                // Include the table's own indexes/triggers (tbl_name match),
+                // not just the object literally named NAME.
+                let escaped = escapeSQLString(name)
+                sql += " AND (name='\(escaped)' OR tbl_name='\(escaped)')"
             }
             sql += " ORDER BY (type='table') DESC, name;"
             return await emitSchemaSQL(connection, sql)
@@ -135,6 +138,12 @@ enum DotCommandRunner {
             // No `PRAGMA foreign_keys=OFF;` here: replaying the dump through
             // this sandboxed command would hit the all-PRAGMA-denied
             // authorizer. The whole restore runs in one transaction instead.
+            //
+            // Limitation: rows are emitted in table-name order, not foreign-key
+            // dependency order, and foreign_keys can't be toggled off in the
+            // sandbox — so restoring a dump of FK-constrained tables can fail
+            // when a child row precedes its parent. Adequate for inspection;
+            // a dependency-ordered dump is future work.
             var out = "BEGIN TRANSACTION;\n"
             var schemaSQL = "SELECT type, name, sql FROM sqlite_schema "
                 + "WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\'"
@@ -331,7 +340,13 @@ func sqlLiteral(_ value: SQLiteValue) -> String {
     switch value {
     case .null: return "NULL"
     case .integer(let i): return String(i)
-    case .real(let d): return String(d)
+    case .real(let d):
+        // String(infinity) is "inf", which SQLite parses as an identifier,
+        // not a number — emit a restorable numeric literal instead. (SQLite
+        // normalizes NaN to NULL on storage, so NaN shouldn't occur.)
+        if d.isFinite { return String(d) }
+        if d.isNaN { return "NULL" }
+        return d > 0 ? "9e999" : "-9e999"
     case .text(let s): return "'\(escapeSQLString(s))'"
     case .blob(let data): return blobLiteral(data)
     }

Sources/SwiftSQLiteKit/EngineContext.swift

@@ -110,6 +110,12 @@ final class EngineContext: @unchecked Sendable {
     private func guardedObjectName(action: Int32, arg1: String?, arg2: String?) -> String? {
         switch action {
         case SQLITE_ALTER_TABLE:
+            // arg2 is the table being altered (its OLD name on a RENAME).
+            // Limitation: SQLite doesn't pass the NEW name to the authorizer,
+            // so `ALTER TABLE t RENAME TO _audit_x` isn't caught by the
+            // reserved-prefix guard. Low severity — the audit trail is an
+            // external file, not an in-DB `_audit*` table, so the reserved
+            // namespace is defense-in-depth only.
             return arg2
         case SQLITE_CREATE_INDEX, SQLITE_CREATE_TEMP_INDEX,
              SQLITE_DROP_INDEX, SQLITE_DROP_TEMP_INDEX,