kreftjs 0.0.21-beta → 0.0.23-beta.0

package/bin/artisan.js

@@ -262,7 +262,9 @@ class ${name} {
   // POST /api/${plural(snake(model))}
   async store(req) {
     // const data = await req.validate({ title: 'required|max:200' })
-    const data = req.all()
+    // only the columns listed in static fillable on the model are taken: never req.all(), or a visitor could send
+    // { "is_admin": true } and have it saved
+    const data = req.only(...(${model}.fillable || abort(500, 'Set static fillable on the ${model} model first (the columns a visitor may fill).')))
     // if (data.title && !data.slug) data.slug = await slug.unique(${model}, 'slug', data.title)
     return response(await ${model}.create(data), 201)
   }
@@ -276,7 +278,7 @@ class ${name} {
   async update(req, id) {
     const ${snake(model)} = await ${model}.findOrFail(id)
     // const data = await req.validate({ title: 'sometimes|required|max:200' })
-    const data = req.all()
+    const data = req.only(...(${model}.fillable || abort(500, 'Set static fillable on the ${model} model first (the columns a visitor may fill).')))
     return ${snake(model)}.update(data)
   }
 

package/bin/backend/cache.js

@@ -19,15 +19,41 @@ const { parseJson } = require('../safe-json.js');
 const nowSec = () => Math.floor(Date.now() / 1000);
 const expiry = (seconds) => (seconds == null ? 0 : nowSec() + Math.max(1, Math.floor(seconds instanceof Date ? (seconds - Date.now()) / 1000 : seconds)));
 
+// In-process store with LRU eviction: at most CACHE_MEMORY_MAX entries (default 5000), and under
+// memory pressure the memory manager (gc.js) trims the least recently used ones instead of flushing all.
 function memoryStore() {
-  const map = new Map();
-  return {
-    async get(key) { const e = map.get(key); if (!e) return undefined; if (e.exp && e.exp <= nowSec()) { map.delete(key); return undefined; } return e.value; },
-    async put(key, value, exp) { map.set(key, { value, exp }); },
-    async add(key, value, exp) { if ((await this.get(key)) !== undefined) return false; map.set(key, { value, exp }); return true; },
+  const map = new Map(); // insertion order = recency: the first key is the least recently used
+  const max = Math.max(1, Number(process.env.CACHE_MEMORY_MAX) || 5000);
+  const set = (key, entry) => {
+    map.delete(key);
+    map.set(key, entry);
+    while (map.size > max) map.delete(map.keys().next().value);
+  };
+  const store = {
+    async get(key) {
+      const e = map.get(key);
+      if (!e) return undefined;
+      if (e.exp && e.exp <= nowSec()) { map.delete(key); return undefined; }
+      map.delete(key); map.set(key, e); // mark as recently used
+      return e.value;
+    },
+    async put(key, value, exp) { set(key, { value, exp }); },
+    async add(key, value, exp) { if ((await this.get(key)) !== undefined) return false; set(key, { value, exp }); return true; },
     async forget(key) { return map.delete(key); },
     async flush() { map.clear(); },
+    size: () => map.size,
+    /** Drops expired entries, then the least recently used `fraction` of what is left. Returns how many went. */
+    trim(fraction = 0.5) {
+      const before = map.size;
+      const now = nowSec();
+      for (const [k, e] of map) if (e.exp && e.exp <= now) map.delete(k);
+      let drop = Math.ceil(map.size * Math.min(1, Math.max(0, fraction)));
+      for (const k of map.keys()) { if (drop-- <= 0) break; map.delete(k); }
+      return before - map.size;
+    },
   };
+  try { require('./gc.js').onMemoryPressure('cache:memory', (fraction) => store.trim(fraction)); } catch (_) {}
+  return store;
 }
 function fileStore(dir) {
   const file = (key) => path.join(dir, crypto.createHash('sha1').update(key).digest('hex'));

package/bin/backend/gc.js

@@ -1,69 +1,219 @@
 /*
- * Kreft Auto Garbage Collector & Memory Watchdog
+ * Kreft Memory Manager (Auto GC + watchdog)
  *
- * Keeps Kreft server instances blazing fast and lightweight, preventing V8 heap
- * bloating during continuous development and production traffic.
+ *   - Adaptive GC: a cleanup runs when the heap passes the threshold OR when it keeps growing
+ *     (trend over the last samples) while already past 60% of the threshold.
+ *   - Smart eviction: caches register a handler (onMemoryPressure) and drop their least recently
+ *     used entries, a fraction at a time, instead of being flushed whole.
+ *   - Leak detection: after each real GC the heap "floor" is recorded; a floor that keeps rising
+ *     across collections is reported as a suspected leak.
+ *   - Alerts: onMemoryAlert(fn) is called when memory stays high despite cleaning, or a leak is suspected.
+ *   - Report: getMemoryReport() returns samples, GC count, evictions, leak state and alerts.
+ *
+ * Env: AUTO_GC_THRESHOLD_MB (250), AUTO_GC_INTERVAL_MS (30000), AUTO_GC_GROWTH_MB_PER_MIN (20),
+ *      AUTO_GC_ALERT_AFTER (3 checks), AUTO_GC_LEAK_RISE_MB (20). `--gc` / AUTO_GC=1 exposes global.gc.
  */
+const MB = 1024 * 1024;
+const HISTORY_MAX = 120;
+
 let gcTimer = null;
-let lastMemoryUsage = null;
+let config = null;
+let observer = null;
+
+const history = [];
+const pressureHandlers = new Map();
+const alertListeners = new Set();
+const floors = [];
+const state = freshState();
+
+function freshState() {
+  return {
+    startedAt: null, checks: 0, cleanups: 0, gcRuns: 0, v8Collections: 0, reclaimedMB: 0,
+    evicted: 0, overStreak: 0, alerts: [], lastAlertAt: 0, leak: { suspected: false, riseMB: 0, floorsMB: [] },
+  };
+}
+
+const round = (n) => +(n).toFixed(2);
+
+/** Register a handler called under memory pressure: fn(fraction) → number of entries dropped. */
+function onMemoryPressure(name, fn) {
+  pressureHandlers.set(name, fn);
+  return () => pressureHandlers.delete(name);
+}
+
+/** Be told when memory stays high after cleaning, or a leak looks likely. fn(alert) */
+function onMemoryAlert(fn) {
+  alertListeners.add(fn);
+  return () => alertListeners.delete(fn);
+}
+
+// Slope of the heap in MB per minute over the most recent samples (least squares); null with too few samples.
+function trendMBPerMin(n = 10) {
+  const pts = history.slice(-n);
+  if (pts.length < 4) return null;
+  const t0 = pts[0].t;
+  const xs = pts.map((p) => (p.t - t0) / 60000);
+  const ys = pts.map((p) => p.heapUsedMB);
+  const mx = xs.reduce((a, b) => a + b, 0) / xs.length;
+  const my = ys.reduce((a, b) => a + b, 0) / ys.length;
+  let num = 0;
+  let den = 0;
+  for (let i = 0; i < xs.length; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; }
+  return den === 0 ? null : round(num / den);
+}
+
+function emitAlert(type, message, extra = {}) {
+  const now = Date.now();
+  if (now - state.lastAlertAt < config.alertCooldownMs) return;
+  state.lastAlertAt = now;
+  const alert = { type, message, at: new Date(now).toISOString(), ...getMemoryStats(), ...extra };
+  state.alerts.push(alert);
+  if (state.alerts.length > 20) state.alerts.shift();
+  for (const fn of alertListeners) { try { fn(alert); } catch (_) {} }
+  if (!alertListeners.size) console.warn(`  [Kreft Memory] ${message}`);
+}
+
+function runCleanup(fraction) {
+  state.cleanups++;
+  for (const fn of pressureHandlers.values()) {
+    try { const n = Number(fn(fraction)); if (n > 0) state.evicted += n; } catch (_) {}
+  }
+  let gcRan = false;
+  if (typeof global.gc === 'function') { global.gc(); state.gcRuns++; gcRan = true; }
+  return gcRan;
+}
+
+function trackLeak() {
+  const f = floors.slice(-6);
+  const rising = f.length >= 4 && f.every((v, i) => i === 0 || v >= f[i - 1] - 0.5);
+  const rise = f.length ? f[f.length - 1] - f[0] : 0;
+  state.leak = { suspected: rising && rise >= config.leakRiseMB, riseMB: round(rise), floorsMB: f.map(round) };
+  if (state.leak.suspected) {
+    emitAlert('memory-leak', `Possible memory leak: the heap after GC rose ${round(rise)} MB over the last ${f.length} collections.`, { leak: state.leak });
+  }
+}
+
+/** One check (the timer calls this; exported so it can be driven directly). */
+function checkMemory() {
+  const mem = process.memoryUsage();
+  const heapUsedMB = mem.heapUsed / MB;
+  history.push({ t: Date.now(), heapUsedMB: round(heapUsedMB), rssMB: round(mem.rss / MB) });
+  if (history.length > HISTORY_MAX) history.shift();
+  state.checks++;
+
+  const trend = trendMBPerMin();
+  const over = heapUsedMB > config.thresholdMB;
+  const growing = trend != null && trend > config.growthMBPerMin && heapUsedMB > config.thresholdMB * 0.6;
+  if (!over && !growing) { state.overStreak = 0; return { action: 'none', heapUsedMB: round(heapUsedMB), trend }; }
+
+  const before = heapUsedMB;
+  const gcRan = runCleanup(over ? 0.75 : 0.5);
+  const after = process.memoryUsage().heapUsed / MB;
+  if (gcRan) {
+    state.reclaimedMB = round(state.reclaimedMB + Math.max(0, before - after));
+    floors.push(after);
+    if (floors.length > 12) floors.shift();
+    trackLeak();
+  }
+  if (config.log) console.log(`  [Kreft GC] ${over ? 'over threshold' : 'growing ' + trend + ' MB/min'}: ${round(before)} → ${round(after)} MB.`);
+
+  if (after > config.thresholdMB * 0.9) {
+    state.overStreak++;
+    if (state.overStreak >= config.alertAfter) {
+      emitAlert('memory-high', `Memory stays high after cleaning: ${round(after)} MB (threshold ${config.thresholdMB} MB) for ${state.overStreak} checks in a row.`, { overStreak: state.overStreak });
+    }
+  } else {
+    state.overStreak = 0;
+  }
+  return { action: over ? 'cleanup-threshold' : 'cleanup-trend', beforeMB: round(before), afterMB: round(after), trend };
+}
 
 function startAutoGarbageCollector(options = {}) {
   if (gcTimer) return;
-  const thresholdMB = Number(options.thresholdMB || process.env.AUTO_GC_THRESHOLD_MB) || 250;
-  const intervalMs = Number(options.intervalMs || process.env.AUTO_GC_INTERVAL_MS) || 30000;
-  const log = options.log || false;
-
-  gcTimer = setInterval(() => {
-    try {
-      const mem = process.memoryUsage();
-      lastMemoryUsage = mem;
-      const heapUsedMB = mem.heapUsed / (1024 * 1024);
-
-      if (heapUsedMB > thresholdMB) {
-        // 1. Purge migrator file caches
-        try {
-          const migrator = require('./migrator.js');
-          if (migrator && typeof migrator.forgetProjectFiles === 'function') {
-            migrator.forgetProjectFiles(process.cwd());
-          }
-        } catch (_) {}
-
-        // 2. Trigger V8 Garbage Collection if exposed (--expose-gc)
-        if (typeof global.gc === 'function') {
-          global.gc();
-          if (log) {
-            const after = process.memoryUsage();
-            const reclaimedMB = (heapUsedMB - after.heapUsed / (1024 * 1024)).toFixed(1);
-            console.log(`  [Kreft GC] Auto-collected ${reclaimedMB} MB heap memory.`);
-          }
-        }
-      }
-    } catch (_) {}
-  }, intervalMs);
+  config = {
+    thresholdMB: Number(options.thresholdMB || process.env.AUTO_GC_THRESHOLD_MB) || 250,
+    intervalMs: Number(options.intervalMs || process.env.AUTO_GC_INTERVAL_MS) || 30000,
+    growthMBPerMin: Number(options.growthMBPerMin || process.env.AUTO_GC_GROWTH_MB_PER_MIN) || 20,
+    alertAfter: Number(options.alertAfter || process.env.AUTO_GC_ALERT_AFTER) || 3,
+    leakRiseMB: Number(options.leakRiseMB || process.env.AUTO_GC_LEAK_RISE_MB) || 20,
+    alertCooldownMs: Number(options.alertCooldownMs) || 10 * 60 * 1000,
+    log: options.log || false,
+  };
+  Object.assign(state, freshState(), { startedAt: new Date().toISOString() });
+  history.length = 0;
+  floors.length = 0;
+
+  // Purge migrator file caches under pressure (always present)
+  onMemoryPressure('migrator', () => {
+    const migrator = require('./migrator.js');
+    if (migrator && typeof migrator.forgetProjectFiles === 'function') migrator.forgetProjectFiles(process.cwd());
+    return 0;
+  });
+
+  try {
+    const { PerformanceObserver } = require('perf_hooks');
+    observer = new PerformanceObserver((list) => { state.v8Collections += list.getEntries().length; });
+    observer.observe({ entryTypes: ['gc'] });
+  } catch (_) { observer = null; }
 
+  gcTimer = setInterval(() => { try { checkMemory(); } catch (_) {} }, config.intervalMs);
   if (gcTimer.unref) gcTimer.unref(); // Don't hold node process open
 }
 
 function stopAutoGarbageCollector() {
-  if (gcTimer) {
-    clearInterval(gcTimer);
-    gcTimer = null;
-  }
+  if (gcTimer) { clearInterval(gcTimer); gcTimer = null; }
+  if (observer) { try { observer.disconnect(); } catch (_) {} observer = null; }
+  pressureHandlers.delete('migrator');
 }
 
 function getMemoryStats() {
   const mem = process.memoryUsage();
   return {
-    rssMB: +(mem.rss / (1024 * 1024)).toFixed(2),
-    heapTotalMB: +(mem.heapTotal / (1024 * 1024)).toFixed(2),
-    heapUsedMB: +(mem.heapUsed / (1024 * 1024)).toFixed(2),
-    externalMB: +(mem.external / (1024 * 1024)).toFixed(2),
+    rssMB: +(mem.rss / MB).toFixed(2),
+    heapTotalMB: +(mem.heapTotal / MB).toFixed(2),
+    heapUsedMB: +(mem.heapUsed / MB).toFixed(2),
+    externalMB: +(mem.external / MB).toFixed(2),
     gcExposed: typeof global.gc === 'function',
   };
 }
 
+/** Everything a dashboard or alert needs, as plain JSON. */
+function getMemoryReport() {
+  return {
+    ...getMemoryStats(),
+    running: !!gcTimer,
+    config,
+    startedAt: state.startedAt,
+    checks: state.checks,
+    cleanups: state.cleanups,
+    gcRuns: state.gcRuns,
+    v8Collections: state.v8Collections,
+    reclaimedMB: state.reclaimedMB,
+    evictedEntries: state.evicted,
+    trendMBPerMin: trendMBPerMin(),
+    overStreak: state.overStreak,
+    leak: state.leak,
+    alerts: state.alerts.slice(),
+    history: history.slice(),
+  };
+}
+
+/** Writes a V8 heap snapshot (open it in Chrome DevTools → Memory) to find what is holding memory. Returns the file path. */
+function writeHeapSnapshot(file) {
+  const path = require('path');
+  const dir = path.join(process.cwd(), 'storage', 'logs');
+  const target = file || path.join(dir, `heap-${Date.now()}.heapsnapshot`);
+  require('fs').mkdirSync(path.dirname(target), { recursive: true });
+  return require('v8').writeHeapSnapshot(target);
+}
+
 module.exports = {
   startAutoGarbageCollector,
   stopAutoGarbageCollector,
   getMemoryStats,
+  getMemoryReport,
+  onMemoryPressure,
+  onMemoryAlert,
+  writeHeapSnapshot,
+  checkMemory,
 };

package/bin/backend/index.js

@@ -453,6 +453,8 @@ module.exports = {
   QR: require('./qr.js').QR,
   ...require('./gc.js'),
   ...require('./mcp.js'),
+  ...require('./mcp-client.js'), // Mcp.connect(url), McpClient
+  ...require('./shield.js'),     // Shield: SHIELD=true in .env limits and bans abusive addresses
   ...require('./config.js'), // config, Config, ConfigRepository
   ...require('./html.js'),   // cleanHtml, sanitizeHtml, stripTags, escapeHtml, e, unescapeHtml, SafeHtml, html
   // for the kreftjs command

package/bin/backend/mcp-client.js

@@ -0,0 +1,133 @@
+/*
+ * MCP client (Streamable HTTP): call tools on a remote MCP server from your app.
+ *
+ *   const { Mcp } = require('kreftjs/server')
+ *   const quran = await Mcp.connect('https://mcp.quran.ai')
+ *   const tools = await quran.tools()
+ *   const out = await quran.call(tools[0].name, { ... })
+ *   await quran.close()
+ *
+ * Options: { headers: { Authorization: 'Bearer …' }, timeout: 30000, maxBytes: 10485760 }
+ *
+ * Security: only http(s) URLs; redirects are refused (a redirect could carry your Authorization header to another
+ * host); a response over maxBytes is cut off. Never pass a URL a visitor typed: the server would then fetch
+ * addresses of your choosing for them (SSRF), including your internal network. Use a fixed or allow-listed URL.
+ */
+class McpClient {
+  constructor(url, options = {}) {
+    this.url = url;
+    this.headers = options.headers || {};
+    this.timeout = options.timeout || 30000;
+    this.maxBytes = options.maxBytes || 10 * 1024 * 1024;
+    let u;
+    try { u = new URL(url); } catch (_) { throw new Error('MCP: not a valid URL: ' + url); }
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') throw new Error('MCP: only http:// and https:// URLs are allowed');
+    this.sessionId = null;
+    this.server = null;
+    this._id = 0;
+  }
+
+  async _post(body) {
+    const headers = {
+      'content-type': 'application/json',
+      accept: 'application/json, text/event-stream',
+      ...this.headers,
+    };
+    if (this.sessionId) headers['mcp-session-id'] = this.sessionId;
+    const res = await fetch(this.url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeout),
+      redirect: 'error',
+    });
+    const sid = res.headers.get('mcp-session-id');
+    if (sid) this.sessionId = sid;
+    if (!res.ok) throw new Error(`MCP ${this.url} answered ${res.status}: ${(await this._readText(res).catch(() => '')).slice(0, 200)}`);
+    if (body.id === undefined) return null; // notification
+    const text = await this._readText(res);
+    const type = res.headers.get('content-type') || '';
+    let msg = null;
+    if (type.includes('text/event-stream')) {
+      for (const block of text.split(/\r?\n\r?\n/)) {
+        const data = block.split(/\r?\n/).filter((l) => l.startsWith('data:')).map((l) => l.slice(5).trimStart()).join('\n');
+        if (!data) continue;
+        try {
+          const m = JSON.parse(data);
+          if (m.id === body.id) { msg = m; break; }
+        } catch { /* skip non-JSON events */ }
+      }
+    } else {
+      msg = JSON.parse(text);
+    }
+    if (!msg) throw new Error('MCP: no response for ' + body.method);
+    if (msg.error) throw new Error(`MCP ${body.method}: ${msg.error.message || JSON.stringify(msg.error)}`);
+    return msg.result;
+  }
+
+  // reads the body but stops at maxBytes, so a hostile or broken server cannot fill the memory
+  async _readText(res) {
+    const len = Number(res.headers.get('content-length'));
+    if (len > this.maxBytes) throw new Error(`MCP: the response is larger than ${this.maxBytes} bytes`);
+    if (!res.body) return '';
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of res.body) {
+      size += chunk.length;
+      if (size > this.maxBytes) { try { await res.body.cancel(); } catch (_) {} throw new Error(`MCP: the response is larger than ${this.maxBytes} bytes`); }
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+  }
+
+  rpc(method, params = {}) {
+    return this._post({ jsonrpc: '2.0', id: ++this._id, method, params });
+  }
+
+  async connect() {
+    const result = await this.rpc('initialize', {
+      protocolVersion: '2025-03-26',
+      capabilities: {},
+      clientInfo: { name: 'kreftjs', version: require('../../package.json').version },
+    });
+    this.server = result;
+    await this._post({ jsonrpc: '2.0', method: 'notifications/initialized' });
+    return this;
+  }
+
+  async tools() {
+    const all = [];
+    let cursor;
+    do {
+      const r = await this.rpc('tools/list', cursor ? { cursor } : {});
+      all.push(...(r.tools || []));
+      cursor = r.nextCursor;
+    } while (cursor);
+    return all;
+  }
+
+  /** Calls a tool. Returns structuredContent when present, else the joined text, else the raw result. */
+  async call(name, args = {}) {
+    const r = await this.rpc('tools/call', { name, arguments: args });
+    if (r.isError) throw new Error(`MCP tool ${name} failed: ${(r.content || []).map((c) => c.text).join(' ')}`);
+    if (r.structuredContent) return r.structuredContent;
+    const text = (r.content || []).filter((c) => c.type === 'text').map((c) => c.text).join('\n');
+    if (!text) return r;
+    try { return JSON.parse(text); } catch { return text; }
+  }
+
+  async resources() { return (await this.rpc('resources/list')).resources || []; }
+  async readResource(uri) { return this.rpc('resources/read', { uri }); }
+
+  async close() {
+    if (!this.sessionId) return;
+    try { await fetch(this.url, { method: 'DELETE', headers: { ...this.headers, 'mcp-session-id': this.sessionId }, signal: AbortSignal.timeout(5000), redirect: 'error' }); } catch { /* server may not support it */ }
+    this.sessionId = null;
+  }
+}
+
+const Mcp = {
+  connect: (url, options) => new McpClient(url, options).connect(),
+};
+
+module.exports = { McpClient, Mcp };

package/bin/backend/mcp.js

@@ -159,6 +159,23 @@ class McpServer {
       };
     });
 
+    // 3b. Tool: memory_report - GC runs, evictions, trend, leak suspicion, alerts, recent samples
+    this.registerTool('memory_report', {
+      description: 'Memory Manager report: heap trend, GC and cache-eviction counts, leak suspicion, recent alerts and samples.',
+      inputSchema: { type: 'object', properties: {} },
+    }, async () => ({
+      content: [{ type: 'text', text: JSON.stringify(require('./gc.js').getMemoryReport(), null, 2) }],
+    }));
+
+    // 3c. Tool: shield_status - the abuse shield: banned addresses, counters, limits
+    this.registerTool('shield_status', {
+      description: 'Kreft Shield (SHIELD=true): whether it is on, its limits, counters, event-loop lag and the currently banned addresses.',
+      inputSchema: { type: 'object', properties: {} },
+    }, async () => {
+      const { Shield } = require('./shield.js');
+      return { content: [{ type: 'text', text: JSON.stringify({ ...Shield.status(), bans: Shield.bans() }, null, 2) }] };
+    });
+
     // 4. Resource: kreft://routes
     const routesResource = async () => {
       const { Route } = require('./index.js');

package/bin/backend/model.js

@@ -255,6 +255,17 @@ class ModelBuilder extends Builder {
   async restore() { const M = this._model; const b = this.clone(); b._trashed = 'only'; return Builder.prototype.update.call(b, { [M.deletedAtColumn]: null }); }
 }
 
+// A model with no `static fillable` lets create()/update() set every column but `id`. If the data came from a request,
+// a visitor could send { "is_admin": true } or { "role": "admin" }. Say so once per model and column.
+const PRIVILEGE_KEY_RE = /^(is_?admin|is_?super_?user|is_?staff|is_?owner|role|roles|role_?id|permissions?|remember_token|api_token|email_verified_at)$/i;
+const warnedFill = new Set();
+function warnPrivilegeFill(C, key) {
+  const id = (C.name || C.table) + '.' + key;
+  if (warnedFill.has(id)) return;
+  warnedFill.add(id);
+  console.warn(`  [Kreft Security] ${C.name || C.table}.${key} is being mass-assigned and the model has no static fillable. If this value can come from a request, a visitor could set it themselves. List the allowed columns in static fillable (or add '${key}' to static guarded); use forceFill() where you really mean it.`);
+}
+
 /* ------------------------------------------------------------------ the model */
 class Model {
   // ---- settings a model can change
@@ -415,7 +426,10 @@ class Model {
     for (const [k, v] of Object.entries(attributes)) {
       if (BAD_KEYS.has(k)) continue;
       const allowed = C.fillable ? C.fillable.includes(k) : !(C.guarded || []).includes(k) && !(C.guarded || []).includes('*');
-      if (allowed) this.setAttribute(k, v);
+      if (allowed) {
+        if (!C.fillable && PRIVILEGE_KEY_RE.test(k)) warnPrivilegeFill(C, k);
+        this.setAttribute(k, v);
+      }
     }
     return this;
   }