oracular 0.12.1 → 0.13.0

package/dist/index.d.cts

@@ -395,7 +395,11 @@ type Migrate = (stored: unknown, version: number) => EngineState;
  * ```
  */
 interface DeserializeOptions {
-    /** The app's current config. Validated, swapped in, and used to prune signals and intents no longer declared. */
+    /**
+     * The app's current config. Validated, swapped in, and used to prune signals and intents no
+     * longer declared; the stored snapshot is then not read, so a key or value a newer release wrote
+     * into it does not stop the load.
+     */
     config?: EngineConfig;
     /**
      * Called when the stored version is neither `STATE_VERSION`, nor one this library migrates
@@ -850,11 +854,14 @@ declare function serialize(state: EngineState): string;
 /**
  * Restores a state saved with {@link serialize}.
  *
- * Always pass the app's current `config`: it is validated and replaces the stored snapshot (the
- * stored one is read without the checks that refuse a config that cannot work, so a state saved
- * before those checks existed still loads),
- * intents and signals no longer declared are dropped (α and β are recomputed from the kept
- * contributions), and newly declared intents start at their prior. States saved by oracular
+ * Always pass the app's current `config`: it is validated and replaces the stored snapshot,
+ * which 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. Intents and signals no longer
+ * declared are dropped (α and β are recomputed from the kept contributions), and newly declared
+ * intents start at their prior. Without a config the stored snapshot runs the engine: it is read
+ * without the checks that refuse a config that cannot work, so a state saved before those checks
+ * existed still loads, but a key the library does not know is an error, since the engine would
+ * otherwise run without an option the state was built under. States saved by oracular
  * 0.1.0 to 0.11.x are upgraded to the current shape on their own, and a state one version newer
  * than {@link STATE_VERSION} (written by the next release, read after a rollback) is read as the
  * current one, ignoring the fields it adds; `migrate` is only for a version this library does

package/dist/index.d.ts

@@ -395,7 +395,11 @@ type Migrate = (stored: unknown, version: number) => EngineState;
  * ```
  */
 interface DeserializeOptions {
-    /** The app's current config. Validated, swapped in, and used to prune signals and intents no longer declared. */
+    /**
+     * The app's current config. Validated, swapped in, and used to prune signals and intents no
+     * longer declared; the stored snapshot is then not read, so a key or value a newer release wrote
+     * into it does not stop the load.
+     */
     config?: EngineConfig;
     /**
      * Called when the stored version is neither `STATE_VERSION`, nor one this library migrates
@@ -850,11 +854,14 @@ declare function serialize(state: EngineState): string;
 /**
  * Restores a state saved with {@link serialize}.
  *
- * Always pass the app's current `config`: it is validated and replaces the stored snapshot (the
- * stored one is read without the checks that refuse a config that cannot work, so a state saved
- * before those checks existed still loads),
- * intents and signals no longer declared are dropped (α and β are recomputed from the kept
- * contributions), and newly declared intents start at their prior. States saved by oracular
+ * Always pass the app's current `config`: it is validated and replaces the stored snapshot,
+ * which 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. Intents and signals no longer
+ * declared are dropped (α and β are recomputed from the kept contributions), and newly declared
+ * intents start at their prior. Without a config the stored snapshot runs the engine: it is read
+ * without the checks that refuse a config that cannot work, so a state saved before those checks
+ * existed still loads, but a key the library does not know is an error, since the engine would
+ * otherwise run without an option the state was built under. States saved by oracular
  * 0.1.0 to 0.11.x are upgraded to the current shape on their own, and a state one version newer
  * than {@link STATE_VERSION} (written by the next release, read after a rollback) is read as the
  * current one, ignoring the fields it adds; `migrate` is only for a version this library does

package/dist/index.js

@@ -1003,9 +1003,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}`);
@@ -1114,16 +1114,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")