@markii/lua 0.3.1 → 0.4.0

package/README.md

@@ -1,5 +1,5 @@
 # @markii/lua
 
-A sandboxed Lua 5.4 (via `wasmoon`) execution runtime for [Mark](https://github.com/sadigaxund/markii)'s document scripting: an empty-environment global whitelist, capability-gated net/cache/bundle access, instruction-count and wall-clock/memory limits, and depth/size-capped Lua↔JS value marshaling. No React, no markdown parsing.
+A sandboxed Lua 5.4 (via `wasmoon`) execution runtime for [Markii](https://github.com/sadigaxund/markii)'s document scripting: an empty-environment global whitelist, capability-gated net/cache/bundle access, instruction-count and wall-clock/memory limits, and depth/size-capped Lua↔JS value marshaling. No React, no markdown parsing.
 
 See the [repository](https://github.com/sadigaxund/markii) for the format spec and the reference library as a whole.

package/dist/capabilities.js

@@ -390,28 +390,58 @@ net.patch = function(url, body) return __smd_net_patch_blocked(url, body):await(
             // below — so without this check, a 300k-element cached array reached
             // the script completely uncapped even though the FETCH path was
             // already capped.
-            const budgetCheck = checkJsonWithinLimits(entry.value, marshalLimits);
-            if (!budgetCheck.ok) {
-                const message = `cached value for "${key}" ${budgetCheck.message}`;
-                recordDenial('denied', message);
-                throw capabilityError(message);
+            //
+            // An entry that fails the budget check, isn't a plain object at all,
+            // or carries a missing/non-finite `storedAtMs` (adversarial finding:
+            // a poisoned host snapshot like `{value: 'x'}` with no `storedAtMs`,
+            // or `storedAtMs: 'abc'`, would otherwise reach the Lua-side
+            // `now - storedAtMs` arithmetic in `cache.get` below and throw a
+            // script-error, wedging the note permanently instead of self-healing)
+            // — or that cannot be `JSON.stringify`'d at all (cyclic, or
+            // BigInt-bearing — something other than this sandbox's own WRITE
+            // side must have written it, since that side already rejects both) —
+            // is SELF-HEALED rather than denied (orchestrator decision, #6
+            // verification notes): it is treated as a cache MISS, exactly as if
+            // `key` had never been stored. `cache.get`'s Lua body (below) then
+            // calls `fn()` and writes the fresh, already-capped result back
+            // through `__smd_cache_set_raw`, which quietly repairs the stored
+            // entry for next time. No denial is recorded for this path — a
+            // capability denial is reserved for the fresh recompute itself
+            // failing the WRITE side's own caps, which is unchanged.
+            //
+            // Finiteness alone isn't enough (pentest finding N-1): a poisoned
+            // snapshot with a huge FUTURE `storedAtMs` (e.g.
+            // `Number.MAX_SAFE_INTEGER * 1000`) is finite, so it used to pass
+            // straight through to the Lua-side `(now - storedAtMs) < ttl*1000`
+            // freshness check below, which then went hugely negative and
+            // reported the poisoned value as fresh forever — served without
+            // `fn()` ever running. `storedAtMs` must additionally be an integer
+            // and plausible: not before the epoch, and not after "now" as this
+            // same call sees it. `nowMs` is read once, right before the check,
+            // and reused for the equality bound so a genuine entry written and
+            // read in the same millisecond (`storedAtMs === nowMs`) is still a
+            // HIT, not a false self-heal.
+            const nowMs = Date.now();
+            const storedAtMs = entry.storedAtMs;
+            if (typeof entry !== 'object' ||
+                entry === null ||
+                Array.isArray(entry) ||
+                typeof storedAtMs !== 'number' ||
+                !Number.isInteger(storedAtMs) ||
+                storedAtMs < 0 ||
+                storedAtMs > nowMs) {
+                return undefined;
             }
+            const budgetCheck = checkJsonWithinLimits(entry.value, marshalLimits);
+            if (!budgetCheck.ok)
+                return undefined;
             let text;
             try {
-                // A cyclic or BigInt-bearing stored value throws here. This
-                // module's own WRITE side (`__smd_cache_set_raw` below) already
-                // rejects both before ever storing anything, but a `CacheProvider`
-                // is host-controlled storage that something other than this
-                // sandbox could have written — turn that into the same clean,
-                // catchable denial instead of an unclassified throw out of the
-                // capability layer.
                 const encoded = JSON.stringify(entry.value);
                 text = encoded === undefined ? 'null' : encoded;
             }
-            catch (err) {
-                const message = `cached value for "${key}" could not be encoded: ${describeThrown(err)}`;
-                recordDenial('denied', message);
-                throw capabilityError(message);
+            catch {
+                return undefined;
             }
             return LuaMultiReturn.of(text, entry.storedAtMs);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markii/lua",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Sandboxed Lua 5.4 (wasmoon) execution runtime for Mark's document scripting: an empty-env global whitelist, two-tier capability-gated net/cache/bundle access, instruction-count/wall-clock/memory limits, and depth/size-capped Lua<->JS marshaling.",
   "keywords": [
     "markdown",
@@ -44,8 +44,8 @@
     "lint": "eslint ."
   },
   "dependencies": {
-    "@markii/bundle": "0.3.1",
-    "@markii/runtime": "0.3.1",
+    "@markii/bundle": "0.4.0",
+    "@markii/runtime": "0.4.0",
     "wasmoon": "^1.16.0"
   }
 }