mikro 0.18.1 → 0.18.2

package/README.md

@@ -60,7 +60,7 @@ The core runtime is a standalone C++ library with no ESP-IDF dependencies. This
 
 - **Engine**: [QuickJS-NG](https://github.com/quickjs-ng/quickjs) ([near-complete ES2024 coverage](https://test262.fyi/#|qjs_ng))
 - **Runtime**: Standalone C++ library with cooperative, single-threaded event loop
-- **Platform**: ESP-IDF >= 6.0.1 (ESP32, ESP32-C3, ESP32-S3, ESP32-C5, ESP32-C6), desktop (macOS, Linux)
+- **Platform**: ESP-IDF >= 6.1 (ESP32, ESP32-C3, ESP32-S3, ESP32-C5, ESP32-C6), desktop (macOS, Linux)
 - **Modules**: Four-source resolution: virtual modules, native C modules, bytecode builtins, filesystem (LittleFS)
 - **Bytecode**: TypeScript bundled with esbuild, compiled to QuickJS bytecode at build time
 - **Tooling**: Node.js CLI (Ink/React), Node-API addon for host-side development and simulation

package/dist/_exports/ota.d.ts

@@ -1,3 +1,3 @@
-export type { ApplyOutcome, Diagnostic, DownloadFn, InstallOptions, InstallOutcome, Offer, Ota, OtaBeginError, OtaDownloadError, OtaError, OtaInstallError, OtaWriteError, RunningBuild, Update, } from '@mikrojs/native/runtime/ota/types';
+export type { ApplyOutcome, ConfigErrorReport, ConfigState, ConfigWrite, Diagnostic, DownloadFn, InstallOptions, InstallOutcome, Offer, Ota, OtaBeginError, OtaDownloadError, OtaError, OtaInstallError, OtaWriteError, RunningBuild, StoredConfig, Update, } from '@mikrojs/native/runtime/ota/types';
 export { ota } from '@mikrojs/native/runtime/ota/types';
 //# sourceMappingURL=ota.d.ts.map

package/dist/_exports/ota.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ota.d.ts","sourceRoot":"","sources":["../../src/_exports/ota.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,UAAU,EACV,UAAU,EACV,cAAc,EACd,cAAc,EACd,KAAK,EACL,GAAG,EACH,aAAa,EACb,gBAAgB,EAChB,QAAQ,EACR,eAAe,EACf,aAAa,EACb,YAAY,EACZ,MAAM,GACP,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAC,GAAG,EAAC,MAAM,mCAAmC,CAAA"}
+{"version":3,"file":"ota.d.ts","sourceRoot":"","sources":["../../src/_exports/ota.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,WAAW,EACX,UAAU,EACV,UAAU,EACV,cAAc,EACd,cAAc,EACd,KAAK,EACL,GAAG,EACH,aAAa,EACb,gBAAgB,EAChB,QAAQ,EACR,eAAe,EACf,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,MAAM,GACP,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAC,GAAG,EAAC,MAAM,mCAAmC,CAAA"}

package/dist/_exports/ota.js.map

@@ -1 +1 @@
-{"version":3,"file":"ota.js","sourceRoot":"","sources":["../../src/_exports/ota.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAC,GAAG,EAAC,MAAM,mCAAmC,CAAA"}
+{"version":3,"file":"ota.js","sourceRoot":"","sources":["../../src/_exports/ota.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,GAAG,EAAC,MAAM,mCAAmC,CAAA"}

package/dist/simulator/builtins/ota-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ota-client.d.ts","sourceRoot":"","sources":["../../../src/simulator/builtins/ota-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,YAAY,CAAA;AAajD,eAAO,MAAM,gBAAgB,EAAE,iBAiK9B,CAAA"}
+{"version":3,"file":"ota-client.d.ts","sourceRoot":"","sources":["../../../src/simulator/builtins/ota-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,YAAY,CAAA;AAcjD,eAAO,MAAM,gBAAgB,EAAE,iBAuS9B,CAAA"}

package/dist/simulator/builtins/ota-client.js

@@ -8,10 +8,11 @@
 // pretending to run a round. Everything else is simulated: the host has no app
 // partition, but the staging -> finish -> reconcile -> confirm/revert sequence
 // is the part an app's own update code drives, and it runs here in memory.
-// `config()` serves whatever the session's mik.sys `ota.cfg` slot holds.
+// `config()` serves whatever the session's mik.sys `ota.cfg` slot holds, and
+// `applyConfig()` is what puts a document there.
 export const otaClientBuiltin = {
     source: `
-import {sysGet} from 'native:mikro/nvs_kv'
+import {sysGet, sysRemove, sysSet} from 'native:mikro/nvs_kv'
 import {readFile} from 'mikro/fs'
 import {ok, err} from 'mikro/result'
 
@@ -38,6 +39,7 @@ export function config() {
   const stored = sysGet('ota.cfg')
   const doc = typeof stored === 'object' && stored !== null ? stored.doc : undefined
   const hasDoc = typeof doc === 'object' && doc !== null
+  if (hasDoc) markConfigRead()
   const defaults = manifestDefaults()
   if (defaults === undefined) {
     if (hasDoc) return doc
@@ -54,16 +56,31 @@ export function config() {
 // materialized defaults is an app that declares no config schema, whose config
 // is {}, not a failure. Mirrors the device reader (src/mik_ota_config.cpp).
 function manifestDefaults() {
-  const manifest = readFile('/app/mikro.app.json', 'utf-8')
-  if (!manifest.ok) return undefined
+  const parsed = manifest()
+  if (parsed === undefined) return undefined
+  const held = parsed.configDefaults
+  return typeof held === 'object' && held !== null ? held : {}
+}
+
+// The running app's version, which is what decides where a delivered document
+// belongs. The manifest carries the same value the device reads out of
+// /app/package.json.
+function manifestVersion() {
+  const parsed = manifest()
+  const version = parsed === undefined ? undefined : parsed.version
+  return typeof version === 'string' && version !== '' ? version : undefined
+}
+
+function manifest() {
+  const text = readFile('/app/mikro.app.json', 'utf-8')
+  if (!text.ok) return undefined
   let parsed
   try {
-    parsed = JSON.parse(manifest.value)
+    parsed = JSON.parse(text.value)
   } catch {
     return undefined
   }
-  const held = parsed === null ? undefined : parsed.configDefaults
-  return typeof held === 'object' && held !== null ? held : {}
+  return typeof parsed === 'object' && parsed !== null ? parsed : undefined
 }
 
 export function bearer() {
@@ -76,6 +93,113 @@ export function registry() {
   return typeof url === 'string' && url !== '' ? url : undefined
 }
 
+// ── config delivery ──────────────────────────────────────────────────────────
+// Mirrors src/mik_ota_config.cpp. A sim run is one boot, so a trial is armed
+// and can be adopted here, but never burned down to a rollback: that needs the
+// power cycles only a device has.
+
+export function parseConfig(raw) {
+  if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) return undefined
+  const version = raw.version
+  // Bounded by the buffers the device stores them in. A truncated rev would
+  // never match the one the registry issued, so it is rejected, not cut.
+  if (typeof version !== 'string' || version === '' || version.length > 31) return undefined
+  const rev = raw.rev
+  const hasRev = rev !== undefined && rev !== null
+  if (hasRev && (typeof rev !== 'string' || rev.length > 64)) return undefined
+  const doc = raw.doc
+  const hasDoc = doc !== undefined && doc !== null
+  // The document is spread over the defaults top level: anything that is not a
+  // plain object has no keys to spread. An absent doc is the clear.
+  if (hasDoc && (typeof doc !== 'object' || Array.isArray(doc))) return undefined
+  const out = {version}
+  if (hasRev && rev !== '') out.rev = rev
+  if (hasDoc) out.doc = doc
+  return out
+}
+
+export function applyConfig(config, options) {
+  const parsed = parseConfig(config)
+  if (parsed === undefined) return 'invalid'
+  const version = manifestVersion()
+  // Which slot the document belongs in is unknown without the running version,
+  // and storing it in either would be a guess the reader drops in silence.
+  if (version === undefined) return 'failed'
+
+  if (parsed.version !== version) {
+    // Stamped for another release: it applies with the build it names.
+    if (parsed.doc === undefined) sysRemove('ota.cfgNext')
+    else sysSet('ota.cfgNext', parsed)
+    return 'staged'
+  }
+
+  const held = sysGet('ota.cfg')
+  const heldCfg = typeof held === 'object' && held !== null ? held : undefined
+
+  if (parsed.doc === undefined) {
+    // A rev riding along does not turn a clear into a document.
+    sysRemove('ota.cfgTrial')
+    sysRemove('ota.cfgErr')
+    sysRemove('ota.cfgPrev')
+    if (heldCfg === undefined) return 'unchanged'
+    sysRemove('ota.cfg')
+    return 'cleared'
+  }
+
+  // An identical document must cost nothing: re-storing it would put a document
+  // that already passed its trial back on trial. The rev counts as part of it.
+  if (heldCfg !== undefined && sameConfig(heldCfg, parsed)) return 'unchanged'
+
+  // The document it replaces is the rollback baseline: a schema-valid value can
+  // still be fatal to the app.
+  if (heldCfg === undefined) sysRemove('ota.cfgPrev')
+  else sysSet('ota.cfgPrev', heldCfg)
+  sysSet('ota.cfg', parsed)
+  let trialBoots = 1
+  if (options !== undefined && typeof options.trialBoots === 'number' && options.trialBoots >= 1) {
+    trialBoots = options.trialBoots
+  }
+  sysSet('ota.cfgTrial', {left: trialBoots, read: false})
+  sysRemove('ota.cfgErr')
+  return 'applied'
+}
+
+export function configState() {
+  const out = {}
+  const report = sysGet('ota.cfgErr')
+  const hasError =
+    typeof report === 'object' && report !== null && typeof report.rev === 'string'
+  if (hasError) {
+    out.error = {
+      rev: report.rev,
+      message: typeof report.message === 'string' ? report.message : '',
+    }
+  }
+  // After a rollback the FAILED document's rev is the one to echo, not the
+  // restored one's: that is what stops the registry serving it again.
+  const held = sysGet('ota.cfg')
+  const heldRev =
+    typeof held === 'object' && held !== null && typeof held.rev === 'string' ? held.rev : ''
+  const rev = hasError ? report.rev : heldRev
+  if (rev !== '') out.rev = rev
+  return out
+}
+
+function sameConfig(held, next) {
+  const heldRev = typeof held.rev === 'string' ? held.rev : ''
+  const nextRev = typeof next.rev === 'string' ? next.rev : ''
+  if (heldRev !== nextRev || held.version !== next.version) return false
+  return JSON.stringify(held.doc) === JSON.stringify(next.doc)
+}
+
+// A document the app has read is a document the app ran with, which is what a
+// later confirm() adopts on.
+function markConfigRead() {
+  const trial = sysGet('ota.cfgTrial')
+  if (typeof trial !== 'object' || trial === null || trial.read === true) return
+  sysSet('ota.cfgTrial', {left: trial.left, read: true})
+}
+
 // ── the in-memory build state ────────────────────────────────────────────────
 
 let current = {checksum: undefined, version: undefined, trial: false}
@@ -89,11 +213,22 @@ function install(checksum) {
 }
 
 export function running() {
-  return {checksum: current.checksum, version: current.version, trial: current.trial}
+  // The version falls back to the manifest, the way mik__ota_policy_running
+  // falls back to read_app_version: an app needs it to stamp what it delivers.
+  const version = current.version === undefined ? manifestVersion() : current.version
+  return {checksum: current.checksum, version, trial: current.trial}
 }
 
 export function confirm() {
   current = {checksum: current.checksum, version: current.version, trial: false}
+  // One confirm settles both trials, as on device (mik__ota_policy_confirm).
+  // The config trial waits additionally for the app to have read the document.
+  const trial = sysGet('ota.cfgTrial')
+  const armed = typeof trial === 'object' && trial !== null
+  if (!armed || trial.read === true) {
+    sysRemove('ota.cfgPrev')
+    sysRemove('ota.cfgTrial')
+  }
 }
 
 export function revert() {

package/dist/simulator/builtins/ota-client.js.map

@@ -1 +1 @@
-{"version":3,"file":"ota-client.js","sourceRoot":"","sources":["../../../src/simulator/builtins/ota-client.ts"],"names":[],"mappings":"AAEA,6EAA6E;AAC7E,6DAA6D;AAC7D,4EAA4E;AAC5E,gFAAgF;AAChF,yDAAyD;AACzD,EAAE;AACF,wEAAwE;AACxE,+EAA+E;AAC/E,+EAA+E;AAC/E,2EAA2E;AAC3E,yEAAyE;AACzE,MAAM,CAAC,MAAM,gBAAgB,GAAsB;IACjD,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+JT;CACA,CAAA"}
+{"version":3,"file":"ota-client.js","sourceRoot":"","sources":["../../../src/simulator/builtins/ota-client.ts"],"names":[],"mappings":"AAEA,6EAA6E;AAC7E,6DAA6D;AAC7D,4EAA4E;AAC5E,gFAAgF;AAChF,yDAAyD;AACzD,EAAE;AACF,wEAAwE;AACxE,+EAA+E;AAC/E,+EAA+E;AAC/E,2EAA2E;AAC3E,6EAA6E;AAC7E,iDAAiD;AACjD,MAAM,CAAC,MAAM,gBAAgB,GAAsB;IACjD,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqST;CACA,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikro",
-  "version": "0.18.1",
+  "version": "0.18.2",
   "description": "Mikro.js: TypeScript for microcontrollers",
   "keywords": [
     "embedded",
@@ -97,11 +97,11 @@
     "tar": "^7.5.13",
     "uint8array-extras": "^1.5.0",
     "update-notifier": "^7.3.1",
-    "@mikrojs/analyze-imports": "0.18.1",
-    "@mikrojs/esptool": "0.18.1",
-    "@mikrojs/firmware": "0.18.1",
-    "@mikrojs/native": "0.18.1",
-    "@mikrojs/quickjs": "0.18.1"
+    "@mikrojs/analyze-imports": "0.18.2",
+    "@mikrojs/firmware": "0.18.2",
+    "@mikrojs/native": "0.18.2",
+    "@mikrojs/quickjs": "0.18.2",
+    "@mikrojs/esptool": "0.18.2"
   },
   "devDependencies": {
     "@swc/core": "^1.15.30",