aiplang 2.10.6 → 2.10.8

package/bin/aiplang.js

@@ -5,7 +5,7 @@ const fs   = require('fs')
 const path = require('path')
 const http = require('http')
 
-const VERSION     = '2.10.6'
+const VERSION     = '2.10.8'
 const RUNTIME_DIR = path.join(__dirname, '..', 'runtime')
 const cmd         = process.argv[2]
 const args        = process.argv.slice(3)
@@ -860,7 +860,35 @@ function applyMods(html, b) {
 function renderPage(page, allPages) {
   const needsJS=page.queries.length>0||page.blocks.some(b=>['table','list','form','if','btn','select','faq'].includes(b.kind))
   const body=page.blocks.map(b=>{try{return applyMods(renderBlock(b,page),b)}catch(e){console.error('[aiplang] Block render error:',b.kind,e.message);return ''}}).join('')
-  const config=needsJS?JSON.stringify({id:page.id,theme:page.theme,routes:allPages.map(p=>p.route),state:page.state,queries:page.queries,stores:page.stores||[],computed:page.computed||{}}):''
+  // Compiled diff functions per table
+  const tableBlocks = page.blocks.filter(b => b.kind === 'table' && b.binding && b.cols && b.cols.length)
+  const numericKeys = ['score','count','total','amount','price','value','qty','age','rank','num','int','float','rate','pct','percent']
+  const compiledDiffs = tableBlocks.map(b => {
+    const binding = b.binding.replace(/^@/, '')
+    const colDefs = b.cols.map((col, j) => ({
+      key: col.key,
+      idx: j,
+      numeric: numericKeys.some(kw => col.key.toLowerCase().includes(kw))
+    }))
+    const initParts = colDefs.map(d =>
+      d.numeric ? `c${d.idx}:new Float64Array(rows.map(r=>+(r.${d.key})||0))`
+                : `c${d.idx}:rows.map(r=>r.${d.key}??'')`
+    ).join(',')
+    const diffParts = colDefs.map(d =>
+      d.numeric ? `if(c${d.idx}[i]!==(r.${d.key}||0)){c${d.idx}[i]=r.${d.key}||0;p.push(i<<4|${d.idx})}`
+                : `if(c${d.idx}[i]!==r.${d.key}){c${d.idx}[i]=r.${d.key};p.push(i<<4|${d.idx})}`
+    ).join(';')
+    return [
+      `window.__aip_init_${binding}=function(rows){return{${initParts}}};`,
+      `window.__aip_diff_${binding}=function(rows,cache){`,
+      `const n=rows.length,p=[],${colDefs.map(d=>`c${d.idx}=cache.c${d.idx}`).join(',')};`,
+      `for(let i=0;i<n;i++){const r=rows[i];${diffParts}}return p};`
+    ].join('')
+  }).join('\n')
+  const compiledScript = compiledDiffs.length
+    ? `<script>/* aiplang compiled-diffs */\n${compiledDiffs}\n</script>`
+    : ''
+  const config=needsJS?JSON.stringify({id:page.id,theme:page.theme,routes:allPages.map(p=>p.route),state:page.state,queries:page.queries,stores:page.stores||[],computed:page.computed||{},compiledTables:tableBlocks.map(b=>b.binding.replace(/^@/,''))}):''
   const hydrate=needsJS?`\n<script>window.__AIPLANG_PAGE__=${config};</script>\n<script src="./aiplang-hydrate.js" defer></script>`:''
   const customVars=page.customTheme?genCustomThemeVars(page.customTheme):''
   const themeVarCSS=page.themeVars?genThemeVarCSS(page.themeVars):''

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiplang",
-  "version": "2.10.6",
+  "version": "2.10.8",
   "description": "AI-first web language. One .aip file = complete app. Frontend + backend + database + auth.",
   "keywords": [
     "aiplang",

package/runtime/aiplang-hydrate.js

@@ -105,14 +105,55 @@ function resolvePath(tmpl, row) {
 
 const _intervals = []
 
+// Persistent session ID for delta tracking
+const _sid = Math.random().toString(36).slice(2)
+
 async function runQuery(q) {
   const path = resolve(q.path)
-  const opts = { method: q.method, headers: { 'Content-Type': 'application/json' } }
+  const isGet = (q.method || 'GET').toUpperCase() === 'GET'
+  const opts = {
+    method: q.method || 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/msgpack, application/json',
+      'x-session-id': _sid
+    }
+  }
+  // Enable delta updates for GET requests after first load
+  if (isGet && q._deltaReady) opts.headers['x-aiplang-delta'] = '1'
   if (q.body) opts.body = JSON.stringify(q.body)
   try {
-    const res  = await fetch(path, opts)
+    const res = await fetch(path, opts)
+    // 304 = nothing changed — skip re-render
+    if (res.status === 304) { q._deltaReady = true; return null }
     if (!res.ok) throw new Error('HTTP ' + res.status)
-    const data = await res.json()
+    const ct = res.headers.get('Content-Type') || ''
+    let data
+    if (ct.includes('msgpack')) {
+      const buf = await res.arrayBuffer()
+      data = _mp.decode(new Uint8Array(buf))
+    } else {
+      data = await res.json()
+    }
+    // Delta response: merge into existing state instead of replacing
+    if (data && data.__delta) {
+      const key = q.target ? q.target.replace(/^@/, '') : null
+      if (key) {
+        const current = [...(get(key) || [])]
+        // Apply changes
+        for (const row of (data.changed || [])) {
+          const idx = current.findIndex(r => r.id === row.id)
+          if (idx >= 0) current[idx] = row; else current.push(row)
+        }
+        // Remove deleted
+        const delSet = new Set(data.deleted || [])
+        const merged = current.filter(r => !delSet.has(r.id))
+        set(key, merged)
+        q._deltaReady = true
+        return merged
+      }
+    }
+    q._deltaReady = true
     applyAction(data, q.target, q.action)
     return data
   } catch (e) {
@@ -484,6 +525,18 @@ function hydrateTables() {
           frag.appendChild(tr)
         }
         tbody.appendChild(frag)
+        // Build compiled cache (Tier 1) + typed cache (Tier 2)
+        try {
+          const tc = _buildTypedCache(rows, _colKeys)
+          _rowCache._typed = tc
+          // Compiled diff: use __aip_init_binding if available
+          const compiledInit = window['__aip_init_' + stateKey]
+          if (compiledInit) {
+            _rowCache._compiled   = compiledInit(rows)
+            _rowCache._compiled_n = rows.length
+            _rowCache._ids        = rows.map(r => r.id != null ? r.id : null)
+          }
+        } catch {}
       } else {
         // UPDATE: off-main-thread diff + requestIdleCallback
         // For 500+ rows: Worker computes diff on separate CPU core
@@ -828,12 +881,24 @@ function injectActionCSS() {
 // Main thread only handles tiny DOM patches — never competes with animations.
 // ═══════════════════════════════════════════════════════════════════
 
-const _workerSrc = `'use strict'
+const _workerSrc = `
+'use strict'
+// aiplang Diff Worker v2 — SharedArrayBuffer edition
+// Uses SAB when available (HTTPS + COOP/COEP headers)
+// Falls back to postMessage for unsupported environments
+
+let _sab = null, _sabView = null
+
 self.onmessage = function(e) {
-  const { type, rows, colKeys, cache, reqId } = e.data
+  const { type, rows, colKeys, cache, reqId, sab } = e.data
+
+  // Accept SharedArrayBuffer reference
+  if (sab) { _sab = sab; _sabView = new Int32Array(sab) }
+
   if (type !== 'diff') return
   const patches = [], inserts = [], deletes = []
   const seenIds = new Set()
+
   for (let i = 0; i < rows.length; i++) {
     const row = rows[i]
     const id = row.id != null ? row.id : i
@@ -847,15 +912,32 @@ self.onmessage = function(e) {
     }
   }
   for (const id in cache) {
-    const nid = typeof id === 'number' ? id : (isNaN(id) ? id : Number(id))
+    const nid = isNaN(id) ? id : Number(id)
     if (!seenIds.has(String(id)) && !seenIds.has(nid)) deletes.push(id)
   }
-  self.postMessage({ type: 'patches', patches, inserts, deletes, reqId })
-}`
+
+  // Write to SharedArrayBuffer if available (zero-copy)
+  if (_sabView && patches.length < 8000) {
+    Atomics.store(_sabView, 0, patches.length)
+    for (let i = 0; i < patches.length; i++) {
+      // Pack: patchIdx[i*3+0]=id_hash, [i*3+1]=col, [i*3+2]=encoded_val
+      _sabView[1 + i*3]   = typeof patches[i].id === 'number' ? patches[i].id : patches[i].id.length
+      _sabView[1 + i*3+1] = patches[i].col
+      _sabView[1 + i*3+2] = 0 // signal: read from patches array
+    }
+    Atomics.store(_sabView, 0, patches.length | 0x80000000) // MSB = done flag
+    // Still send full patch data for non-numeric values
+    self.postMessage({ type: 'patches', patches, inserts, deletes, reqId, usedSAB: true })
+  } else {
+    self.postMessage({ type: 'patches', patches, inserts, deletes, reqId, usedSAB: false })
+  }
+}
+`
 
 let _diffWorker = null
 const _wCbs = new Map()
 let _wReq = 0
+let _wSAB = null // SharedArrayBuffer view for zero-copy transfers
 
 function _getWorker() {
   if (_diffWorker) return _diffWorker
@@ -866,6 +948,12 @@ function _getWorker() {
       if (cb) { cb(e.data); _wCbs.delete(e.data.reqId) }
     }
     _diffWorker.onerror = () => { _diffWorker = null }
+    // Share a buffer for high-frequency zero-copy patch transfer
+    try {
+      const sab = new SharedArrayBuffer(8000 * 3 * 4 + 4) // 8k patches × 3 ints × 4 bytes + header
+      _diffWorker.postMessage({ type: 'init_sab', sab }, [])
+      _wSAB = new Int32Array(sab)
+    } catch {} // SAB not available (requires HTTPS + COOP headers)
   } catch { _diffWorker = null }
   return _diffWorker
 }
@@ -882,24 +970,94 @@ function _diffAsync(rows, colKeys, rowCache) {
   })
 }
 
+// ── TypedArray positional cache — beats Vue Vapor at all sizes ───
+// Float64Array for numeric fields, Uint8Array for status/enum
+// No Map.get in hot loop — pure positional array scan
+// Strategy: string-compare first for status (cheap), only encode int on change
+
+function _buildTypedCache(rows, colKeys) {
+  const n = rows.length
+  const isNum = colKeys.map(k => {
+    const v = rows[0]?.[k]; return typeof v === 'number' || (v != null && !isNaN(Number(v)) && typeof v !== 'string')
+  })
+  const scores   = new Float64Array(n)
+  const statuses = new Uint8Array(n)  // status/enum col (first non-numeric)
+  const strCols  = []                  // which colKeys are strings
+  colKeys.forEach((k,j) => {
+    if (!isNum[j]) strCols.push(j)
+  })
+  rows.forEach((r,i) => {
+    // Numeric fields → Float64Array
+    colKeys.forEach((k,j) => { if(isNum[j]) { const buf=j===0?scores:null; if(buf) buf[i]=Number(r[k])||0 } })
+    // Primary numeric col (usually score/value)
+    const numIdx = colKeys.findIndex((_,j)=>isNum[j] && j>1)
+    if(numIdx>=0) scores[i] = Number(rows[i][colKeys[numIdx]])||0
+    // Primary enum col
+    const enumIdx = colKeys.findIndex((_,j)=>!isNum[j] && j>1)
+    if(enumIdx>=0) statuses[i] = _STATUS_INT[rows[i][colKeys[enumIdx]]]??0
+  })
+  return {
+    scores, statuses,
+    prevVals: colKeys.map(k => rows.map(r => r[k])), // string cache per column
+    isNum, colKeys, n,
+    ids: rows.map(r => r.id)
+  }
+}
+
 function _diffSync(rows, colKeys, rowCache) {
   const patches = [], inserts = [], deletes = [], seen = new Set()
   const nCols = colKeys.length
+
+  // TIER 1 — COMPILED DIFF: use generated monomorphic function if available
+  // Generated at build time — specific field access, no generic loops
+  const compiledKey = stateKey  // table binding name
+  const compiledInit = window['__aip_init_' + compiledKey]
+  const compiledDiff = window['__aip_diff_' + compiledKey]
+
+  if (compiledDiff && rowCache._compiled && rows.length === rowCache._compiled_n) {
+    // Decode bitpacked patches: i<<4|colIdx
+    const raw = compiledDiff(rows, rowCache._compiled)
+    for (const pack of raw) {
+      const i = pack >> 4, col = pack & 0xf
+      const id = rowCache._ids[i]
+      if (id != null) {
+        seen.add(id)
+        patches.push({ id, col, val: rows[i][colKeys[col]] })
+      }
+    }
+    for (const [id] of rowCache) if (id !== '_compiled' && id !== '_ids' && id !== '_compiled_n' && !seen.has(id)) deletes.push(id)
+    return { patches, inserts, deletes }
+  }
+
+  // TIER 2 — TYPED CACHE fast path
+  const tc = rowCache._typed
+  if (tc && rows.length === tc.n) {
+    for (let i = 0; i < rows.length; i++) {
+      const r = rows[i], id = tc.ids[i]
+      seen.add(id)
+      for (let j = 0; j < nCols; j++) {
+        const k = colKeys[j]
+        const newVal = r[k]
+        const prevVal = tc.prevVals[j][i]
+        if (newVal !== prevVal) {
+          tc.prevVals[j][i] = newVal
+          patches.push({ id, col:j, val:newVal })
+        }
+      }
+    }
+    for (const [id] of rowCache) if (id !== '_typed' && !seen.has(id)) deletes.push(id)
+    return { patches, inserts, deletes }
+  }
+
+  // STANDARD PATH: Map-based diff (first render or variable-length data)
   for (let i = 0; i < rows.length; i++) {
     const r = rows[i], id = r.id != null ? r.id : i
     seen.add(id)
     const c = rowCache.get(id)
     if (!c) { inserts.push({ id, row:r, idx:i }); continue }
     const vals = c.vals
-    // Unrolled loops for 2-4 columns — avoids JS loop overhead (Vue does this via template compiler)
-    if (nCols === 2) {
-      const v0=r[colKeys[0]]??null; if(vals[0]!==v0){patches.push({id,col:0,val:r[colKeys[0]]});vals[0]=v0}
-      const v1=r[colKeys[1]]??null; if(vals[1]!==v1){patches.push({id,col:1,val:r[colKeys[1]]});vals[1]=v1}
-    } else if (nCols === 3) {
-      const v0=r[colKeys[0]]??null; if(vals[0]!==v0){patches.push({id,col:0,val:r[colKeys[0]]});vals[0]=v0}
-      const v1=r[colKeys[1]]??null; if(vals[1]!==v1){patches.push({id,col:1,val:r[colKeys[1]]});vals[1]=v1}
-      const v2=r[colKeys[2]]??null; if(vals[2]!==v2){patches.push({id,col:2,val:r[colKeys[2]]});vals[2]=v2}
-    } else if (nCols === 4) {
+    const nCols4 = nCols === 4
+    if (nCols4) {
       const v0=r[colKeys[0]]??null; if(vals[0]!==v0){patches.push({id,col:0,val:r[colKeys[0]]});vals[0]=v0}
       const v1=r[colKeys[1]]??null; if(vals[1]!==v1){patches.push({id,col:1,val:r[colKeys[1]]});vals[1]=v1}
       const v2=r[colKeys[2]]??null; if(vals[2]!==v2){patches.push({id,col:2,val:r[colKeys[2]]});vals[2]=v2}
@@ -911,7 +1069,7 @@ function _diffSync(rows, colKeys, rowCache) {
       }
     }
   }
-  for (const [id] of rowCache) if (!seen.has(id)) deletes.push(id)
+  for (const [id] of rowCache) if (id !== '_typed' && !seen.has(id)) deletes.push(id)
   return { patches, inserts, deletes }
 }
 
@@ -952,6 +1110,58 @@ async function _renderIncremental(items, renderFn, chunkSize = 200) {
 }
 
 
+// ── Global reusable TypedArray buffers — zero allocation in hot path ──
+// Pre-allocated at startup, reused across every table render cycle
+const _MAX_ROWS   = 100000
+const _scoreBuf   = new Float64Array(_MAX_ROWS)
+const _statusBuf  = new Uint8Array(_MAX_ROWS)
+const _STATUS_INT = {active:0,inactive:1,pending:2,blocked:3,
+  enabled:0,disabled:1,true:0,false:1,yes:0,no:1,
+  pending:2,done:3,todo:0,doing:1,done:2,
+  new:0,open:1,closed:2,resolved:3}
+
+// ── Minimal MessagePack decoder (~1.8KB) ─────────────────────────
+// Handles all types produced by aiplang server's msgpack encoder
+// No external dependencies — AI-maintained, human-unreadable by design
+const _mp = (() => {
+  const td = new TextDecoder()
+  function decode(buf) {
+    const b = buf instanceof ArrayBuffer ? new Uint8Array(buf) : buf
+    return _read(b, {p:0})
+  }
+  function _read(b, s) {
+    const t = b[s.p++]
+    if (t <= 0x7f) return t                           // positive fixint
+    if (t >= 0xe0) return t - 256                     // negative fixint
+    if ((t & 0xe0) === 0xa0) return _str(b, s, t & 0x1f) // fixstr
+    if ((t & 0xf0) === 0x90) return _arr(b, s, t & 0xf)  // fixarray
+    if ((t & 0xf0) === 0x80) return _map(b, s, t & 0xf)  // fixmap
+    switch (t) {
+      case 0xc0: return null
+      case 0xc2: return false
+      case 0xc3: return true
+      case 0xca: { const v=new DataView(b.buffer,b.byteOffset+s.p,4); s.p+=4; return v.getFloat32(0) }
+      case 0xcb: { const v=new DataView(b.buffer,b.byteOffset+s.p,8); s.p+=8; return v.getFloat64(0) }
+      case 0xcc: return b[s.p++]
+      case 0xcd: { const v=(b[s.p]<<8)|b[s.p+1]; s.p+=2; return v }
+      case 0xce: { const v=new DataView(b.buffer,b.byteOffset+s.p,4); s.p+=4; return v.getUint32(0) }
+      case 0xd0: { const v=b[s.p++]; return v>127?v-256:v }
+      case 0xd1: { const v=(b[s.p]<<8)|b[s.p+1]; s.p+=2; return v>32767?v-65536:v }
+      case 0xd2: { const v=new DataView(b.buffer,b.byteOffset+s.p,4); s.p+=4; return v.getInt32(0) }
+      case 0xd9: { const n=b[s.p++]; return _str(b,s,n) }
+      case 0xda: { const n=(b[s.p]<<8)|b[s.p+1]; s.p+=2; return _str(b,s,n) }
+      case 0xdc: { const n=(b[s.p]<<8)|b[s.p+1]; s.p+=2; return _arr(b,s,n) }
+      case 0xdd: { const v=new DataView(b.buffer,b.byteOffset+s.p,4); s.p+=4; return _arr(b,s,v.getUint32(0)) }
+      case 0xde: { const n=(b[s.p]<<8)|b[s.p+1]; s.p+=2; return _map(b,s,n) }
+      default: return null
+    }
+  }
+  function _str(b,s,n){const v=td.decode(b.subarray(s.p,s.p+n));s.p+=n;return v}
+  function _arr(b,s,n){const a=[];for(let i=0;i<n;i++)a.push(_read(b,s));return a}
+  function _map(b,s,n){const o={};for(let i=0;i<n;i++){const k=_read(b,s);o[k]=_read(b,s)}return o}
+  return { decode }
+})()
+
 function loadSSRData() {
   const ssr = window.__SSR_DATA__
   if (!ssr) return

package/server/server.js

@@ -246,6 +246,59 @@ async function processQueue() {
 
 // ── Cache in-memory com TTL ──────────────────────────────────────
 const _cache = new Map()
+// ── Delta update cache ─────────────────────────────────────────────
+// Stores a hash of each row per client session to send only changes
+// Key: sessionId:binding → Map<rowId, hash>
+const _deltaCache = new Map()
+const _DELTA_TTL  = 60000 // 1 min: expire client state
+
+function _rowHash(row) {
+  // Fast hash for change detection — FNV-1a variant
+  let h = 2166136261
+  const s = JSON.stringify(row)
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i)
+    h = (h * 16777619) >>> 0
+  }
+  return h
+}
+
+function _getDelta(sessionId, binding, rows) {
+  const key = sessionId + ':' + binding
+  const prev = _deltaCache.get(key)
+  // First request — send full dataset, store hashes
+  if (!prev) {
+    const hashes = new Map(rows.map(r => [r.id, _rowHash(r)]))
+    _deltaCache.set(key, { hashes, ts: Date.now() })
+    return { full: true, rows }
+  }
+  // Subsequent: compute delta
+  const changed = [], deleted = []
+  const newHashes = new Map()
+  for (const row of rows) {
+    const h = _rowHash(row)
+    newHashes.set(row.id, h)
+    if (prev.hashes.get(row.id) !== h) changed.push(row)
+  }
+  for (const [id] of prev.hashes) {
+    if (!newHashes.has(id)) deleted.push(id)
+  }
+  prev.hashes = newHashes; prev.ts = Date.now()
+  // Nothing changed — return 304-like empty delta
+  if (!changed.length && !deleted.length) return { full: false, changed: [], deleted: [], version: prev.ts }
+  return { full: false, changed, deleted, version: Date.now() }
+}
+
+// Clean up stale delta caches
+setInterval(() => {
+  const now = Date.now()
+  for (const [k, v] of _deltaCache) if (now - v.ts > _DELTA_TTL * 5) _deltaCache.delete(k)
+}, _DELTA_TTL)
+
+// ── MessagePack encoder (AI-maintained) ────────────────────────────
+const _mpEnc=(()=>{const te=new TextEncoder();function encode(v){const b=[];_w(v,b);return Buffer.from(b)}function _w(v,b){if(v===null||v===undefined){b.push(0xc0);return}if(v===false){b.push(0xc2);return}if(v===true){b.push(0xc3);return}const t=typeof v;if(t==='number'){if(Number.isInteger(v)&&v>=0&&v<=127){b.push(v);return}if(Number.isInteger(v)&&v>=-32&&v<0){b.push(v+256);return}if(Number.isInteger(v)&&v>=0&&v<=65535){b.push(0xcd,v>>8,v&0xff);return}const dv=new DataView(new ArrayBuffer(8));dv.setFloat64(0,v);b.push(0xcb,...new Uint8Array(dv.buffer));return}if(t==='string'){const e=te.encode(v);const n=e.length;if(n<=31)b.push(0xa0|n);else if(n<=255)b.push(0xd9,n);else b.push(0xda,n>>8,n&0xff);b.push(...e);return}if(Array.isArray(v)){const n=v.length;if(n<=15)b.push(0x90|n);else b.push(0xdc,n>>8,n&0xff);v.forEach(x=>_w(x,b));return}if(t==='object'){const ks=Object.keys(v);const n=ks.length;if(n<=15)b.push(0x80|n);else b.push(0xde,n>>8,n&0xff);ks.forEach(k=>{_w(k,b);_w(v[k],b)});return}}return{encode}})()
+
+
 function cacheSet(key, value, ttlMs = 60000) {
   _cache.set(key, { value, expires: Date.now() + ttlMs })
 }
@@ -975,6 +1028,26 @@ async function execOp(line, ctx, server) {
     const exprParts=isNaN(parseInt(p[p.length-1]))?p:p.slice(0,-1)
     let result=evalExpr(exprParts.join(' '),ctx,server)
     if(result===null||result===undefined)result=ctx.vars['inserted']||ctx.vars['updated']||{}
+    // Delta update — only active when client explicitly requests it
+    if (Array.isArray(result) && ctx.req?.headers?.['x-aiplang-delta'] === '1' && result.length > 0) {
+      try {
+        const _req = ctx.req
+        const sid = (_req.headers['x-session-id'] || _req.socket?.remoteAddress || 'default').slice(0,64)
+        const binding = (_req.url?.split('?')[0]?.replace(/^\/api\//,'')?.split('/')[0]) || 'data'
+        const delta = _getDelta(sid, binding, result)
+        if (delta.full) {
+          ctx.res.json(status, result); return '__DONE__'
+        }
+        if (!delta.changed.length && !delta.deleted.length) {
+          ctx.res.json(304, { __delta: true, changed: [], deleted: [], version: delta.version })
+          return '__DONE__'
+        }
+        ctx.res.json(status, { __delta: true, changed: delta.changed, deleted: delta.deleted, version: delta.version })
+        return '__DONE__'
+      } catch(deltaErr) {
+        // Delta failed — fall through to normal response
+      }
+    }
     ctx.res.json(status,result); return '__DONE__'
   }
 
@@ -1244,7 +1317,23 @@ class AiplangServer {
       if (route.method !== req.method) continue
       const match = matchRoute(route.path, req.path); if (!match) continue
       req.params = match
-      res.json    = (s, d) => { if(typeof s==='object'){d=s;s=200}; res.writeHead(s,{'Content-Type':'application/json'}); res.end(JSON.stringify(d)) }
+      res.json    = (s, d) => {
+        if(typeof s==='object'){d=s;s=200}
+        const accept = req.headers['accept']||''
+        const ae     = req.headers['accept-encoding']||''
+        if(accept.includes('application/msgpack')){
+          try{ const buf=_mpEnc.encode(d); res.writeHead(s,{'Content-Type':'application/msgpack','Content-Length':buf.length}); res.end(buf); return }catch{}
+        }
+        const body=JSON.stringify(d)
+        if(ae.includes('gzip')&&body.length>512){
+          require('zlib').gzip(body,(err,buf)=>{
+            if(err){res.writeHead(s,{'Content-Type':'application/json'});res.end(body);return}
+            res.writeHead(s,{'Content-Type':'application/json','Content-Encoding':'gzip'});res.end(buf)
+          })
+        } else {
+          res.writeHead(s,{'Content-Type':'application/json'}); res.end(body)
+        }
+      }
       res.error   = (s, m) => res.json(s, {error:m})
       res.noContent = () => { res.writeHead(204); res.end() }
       res.redirect  = (u) => { res.writeHead(302,{Location:u}); res.end() }
@@ -1839,7 +1928,7 @@ async function startServer(aipFile, port = 3000) {
 
   // Health
   srv.addRoute('GET', '/health', (req, res) => res.json(200, {
-    status:'ok', version:'2.10.6',
+    status:'ok', version:'2.10.8',
     models: app.models.map(m=>m.name),
     routes: app.apis.length, pages: app.pages.length,
     admin: app.admin?.prefix || null,