oracular 0.12.1 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.13.0
+
+### Minor Changes
+
+- [#69](https://github.com/Yuribenjamin/oracular/pull/69) [`02e0c44`](https://github.com/Yuribenjamin/oracular/commit/02e0c44be6e1ac167cf5503a38efd0eb38b1dc2d) Thanks [@Yuribenjamin](https://github.com/Yuribenjamin)! - **A rollback no longer trips over a config key it does not know.** `deserialize` validated the config snapshot stored in the state even when the app passed its current config, which replaces it. So a state written by a release that set a new option (`bound` in 0.8, `learning.lift` in 0.9) threw a `TypeError` in the release before it, the changelogs asked for the key to be removed from the saved config before rolling a deploy back, and in `@oracular/react` the load was a `'parse'` failure that blocked writes until `clear()`. With a config passed, the stored snapshot is now not read at all: a key or a value this release does not know is no obstacle, and every number the state holds comes through as before. Without a config, the stored snapshot runs the engine and is read as it was: without the checks that refuse a config that cannot work, and with a key the library does not know still an error, since the engine would otherwise run without an option the state was built under. Nothing changes for a state that loaded before. Under rule 6 of the stability policy, states now move between releases in both directions for the config snapshot as they already did for the state's fields, and the policy says so.
+
 ## 0.12.1
 
 ### Patch Changes

package/README.md

@@ -356,7 +356,7 @@ localStorage.setItem('oracular', serialize(state));
 const state = deserialize(saved, { config });
 ```
 
-The new config is validated and swapped in. Intents and signals you no longer declare are dropped (α and β are recomputed from what remains), newly declared intents start at their prior, and everything learned about signals that still exist is kept.
+The new config is validated and swapped in. Intents and signals you no longer declare are dropped (α and β are recomputed from what remains), newly declared intents start at their prior, and everything learned about signals that still exist is kept. The stored snapshot is then not read at all, so a state written by a newer release, with a config key or value this one does not know, still loads after a rollback; loading without a config runs the stored snapshot instead, and a key the library does not know is then an error.
 
 States saved by an older version of this library are upgraded on load: `deserialize` migrates the state shapes written by oracular 0.1.0 to 0.11.x (`STATE_VERSION` 1 to 3) to the current one on its own. A `migrate` function is consulted only for a version the library does not know, such as a state written by a newer oracular before a rollback; without one, that throws a `RangeError`:
 

package/dist/index.cjs

@@ -1005,9 +1005,9 @@ function deserialize(json, opts = {}) {
       stored = opts.migrate(parsed, parsed.version);
     }
   }
-  const raw = parseState(stored);
-  const config = opts.config === void 0 ? raw.config : normalizeConfig(opts.config);
-  return requireComputable(reconcile(raw, config));
+  const config = opts.config === void 0 ? void 0 : normalizeConfig(opts.config);
+  const raw = parseState(stored, config);
+  return requireComputable(reconcile(raw, raw.config));
 }
 function typeError2(path, message) {
   throw new TypeError(`oracular: ${path} ${message}`);
@@ -1116,16 +1116,15 @@ function clockState(value, path) {
     behindAt: nullOrFinite(r.behindAt, `${path}.behindAt`)
   };
 }
-function parseState(value) {
+function parseState(value, config) {
   const r = record(value, "state");
   if (r.version !== STATE_VERSION) {
     throw new RangeError(`oracular: state.version must be ${STATE_VERSION} after migration`);
   }
+  const snapshot = record(r.config, "state.config");
   return {
     version: STATE_VERSION,
-    // Without the strict checks: a config this release would refuse at createState still loads
-    // when it is only stored, and the config passed in replaces it anyway.
-    config: normalizeConfig(r.config, false),
+    config: config ?? normalizeConfig(snapshot, false),
     intents: mapOwn(r.intents, "state.intents", intentState),
     episode: episodeState(r.episode, "state.episode"),
     clock: clockState(r.clock, "state.clock")