oracular 0.0.1 → 0.1.0

package/dist/index.js

@@ -0,0 +1,687 @@
+// src/util.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(record2, key) {
+  return Object.prototype.hasOwnProperty.call(record2, key);
+}
+function getOwn(record2, key) {
+  return hasOwn(record2, key) ? record2[key] : void 0;
+}
+function mapRecord(record2, fn) {
+  const out = {};
+  for (const [key, value] of Object.entries(record2)) {
+    out[key] = fn(value, key);
+  }
+  return out;
+}
+
+// src/config.ts
+var DEFAULT_THRESHOLD = 0.5;
+var DEFAULT_Z = 1.28;
+var DEFAULT_GAIN = 2;
+var DEFAULT_PRIOR_EPISODES = 10;
+var CONFIG_KEYS = ["intents", "episodeTimeout", "learning", "reveal"];
+var INTENT_KEYS = [
+  "prior",
+  "priorStrength",
+  "halfLife",
+  "signals",
+  "outcome",
+  "resetOnOutcome",
+  "reveal"
+];
+var REVEAL_KEYS = ["threshold", "z", "cooldown"];
+var LEARNING_KEYS = ["halfLife", "gain", "priorEpisodes"];
+function typeError(path, message) {
+  throw new TypeError(`oracular: ${path} ${message}`);
+}
+function rangeError(path, message) {
+  throw new RangeError(`oracular: ${path} ${message}`);
+}
+function expectRecord(value, path) {
+  if (!isRecord(value)) typeError(path, "must be a plain object");
+  return value;
+}
+function expectKeys(record2, allowed, path) {
+  for (const key of Object.keys(record2)) {
+    if (!allowed.includes(key)) {
+      typeError(
+        `${path}.${key}`,
+        `is not a recognised option (expected one of: ${allowed.join(", ")})`
+      );
+    }
+  }
+}
+function expectNumber(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    typeError(path, "must be a finite number");
+  return value;
+}
+function expectPositive(value, path) {
+  const n = expectNumber(value, path);
+  if (n <= 0) rangeError(path, "must be greater than 0");
+  return n;
+}
+function expectNonNegative(value, path) {
+  const n = expectNumber(value, path);
+  if (n < 0) rangeError(path, "must be 0 or greater");
+  return n;
+}
+function expectOpenUnit(value, path) {
+  const n = expectNumber(value, path);
+  if (n <= 0 || n >= 1) rangeError(path, "must be strictly between 0 and 1");
+  return n;
+}
+function expectClosedUnit(value, path) {
+  const n = expectNumber(value, path);
+  if (n < 0 || n > 1) rangeError(path, "must be between 0 and 1");
+  return n;
+}
+function expectName(value, path) {
+  if (typeof value !== "string" || value.length === 0)
+    typeError(path, "must be a non-empty string");
+  return value;
+}
+function expectKeyName(name, path) {
+  if (name.length === 0) typeError(path, "names must be non-empty strings");
+  if (name === "__proto__") typeError(path, 'must not use the reserved name "__proto__"');
+  return name;
+}
+function normalizeRevealOptions(value, path) {
+  const record2 = expectRecord(value, path);
+  expectKeys(record2, REVEAL_KEYS, path);
+  const out = {};
+  if (record2.threshold !== void 0) {
+    out.threshold = expectClosedUnit(record2.threshold, `${path}.threshold`);
+  }
+  if (record2.z !== void 0) out.z = expectNonNegative(record2.z, `${path}.z`);
+  if (record2.cooldown !== void 0) {
+    out.cooldown = expectNonNegative(record2.cooldown, `${path}.cooldown`);
+  }
+  return out;
+}
+function normalizeLearning(value, path) {
+  const record2 = expectRecord(value, path);
+  expectKeys(record2, LEARNING_KEYS, path);
+  const out = {};
+  if (record2.halfLife !== void 0)
+    out.halfLife = expectPositive(record2.halfLife, `${path}.halfLife`);
+  if (record2.gain !== void 0) out.gain = expectPositive(record2.gain, `${path}.gain`);
+  if (record2.priorEpisodes !== void 0) {
+    out.priorEpisodes = expectPositive(record2.priorEpisodes, `${path}.priorEpisodes`);
+  }
+  return out;
+}
+function normalizeIntent(value, path) {
+  const record2 = expectRecord(value, path);
+  expectKeys(record2, INTENT_KEYS, path);
+  const signalsRecord = expectRecord(record2.signals, `${path}.signals`);
+  const signals = {};
+  for (const [name, weight] of Object.entries(signalsRecord)) {
+    expectKeyName(name, `${path}.signals`);
+    const w = expectNumber(weight, `${path}.signals[${JSON.stringify(name)}]`);
+    if (w === 0) {
+      rangeError(
+        `${path}.signals[${JSON.stringify(name)}]`,
+        "must be non-zero (positive is evidence for the intent, negative is evidence against)"
+      );
+    }
+    signals[name] = w;
+  }
+  const out = {
+    prior: expectOpenUnit(record2.prior, `${path}.prior`),
+    priorStrength: expectPositive(record2.priorStrength, `${path}.priorStrength`),
+    halfLife: expectPositive(record2.halfLife, `${path}.halfLife`),
+    signals
+  };
+  if (record2.outcome !== void 0) out.outcome = expectName(record2.outcome, `${path}.outcome`);
+  if (record2.resetOnOutcome !== void 0) {
+    if (typeof record2.resetOnOutcome !== "boolean") {
+      typeError(`${path}.resetOnOutcome`, "must be a boolean");
+    }
+    out.resetOnOutcome = record2.resetOnOutcome;
+  }
+  if (record2.reveal !== void 0)
+    out.reveal = normalizeRevealOptions(record2.reveal, `${path}.reveal`);
+  return out;
+}
+function normalizeConfig(value) {
+  const record2 = expectRecord(value, "config");
+  expectKeys(record2, CONFIG_KEYS, "config");
+  const intentsRecord = expectRecord(record2.intents, "config.intents");
+  const names = Object.keys(intentsRecord);
+  if (names.length === 0) typeError("config.intents", "must declare at least one intent");
+  const intents = {};
+  for (const name of names) {
+    expectKeyName(name, "config.intents");
+    intents[name] = normalizeIntent(intentsRecord[name], `config.intents[${JSON.stringify(name)}]`);
+  }
+  const out = { intents };
+  if (record2.episodeTimeout !== void 0) {
+    out.episodeTimeout = expectPositive(record2.episodeTimeout, "config.episodeTimeout");
+  }
+  if (record2.learning !== void 0)
+    out.learning = normalizeLearning(record2.learning, "config.learning");
+  if (record2.reveal !== void 0)
+    out.reveal = normalizeRevealOptions(record2.reveal, "config.reveal");
+  return out;
+}
+function resolveReveal(config, intent, opts) {
+  const o = opts === void 0 ? {} : normalizeRevealOptions(opts, "options");
+  return {
+    threshold: o.threshold ?? intent.reveal?.threshold ?? config.reveal?.threshold ?? DEFAULT_THRESHOLD,
+    z: o.z ?? intent.reveal?.z ?? config.reveal?.z ?? DEFAULT_Z,
+    cooldown: o.cooldown ?? intent.reveal?.cooldown ?? config.reveal?.cooldown ?? intent.halfLife
+  };
+}
+function resolveLearning(config) {
+  return {
+    halfLife: config.learning?.halfLife ?? null,
+    gain: config.learning?.gain ?? DEFAULT_GAIN,
+    priorEpisodes: config.learning?.priorEpisodes ?? DEFAULT_PRIOR_EPISODES
+  };
+}
+function expectTimestamp(value, path) {
+  return expectNumber(value, path);
+}
+function validateEvent(event) {
+  if (!isRecord(event)) typeError("event", "must be an object like { name, at }");
+  const name = expectName(event.name, "event.name");
+  const at = expectTimestamp(event.at, "event.at");
+  if (event.props !== void 0 && !isRecord(event.props)) {
+    typeError("event.props", "must be a plain object when present");
+  }
+  return { name, at };
+}
+
+// src/math.ts
+function decayFactor(elapsed, halfLife) {
+  if (!(elapsed > 0) || !Number.isFinite(elapsed)) return 1;
+  return 2 ** (-elapsed / halfLife);
+}
+function betaMean(alpha, beta) {
+  return alpha / (alpha + beta);
+}
+function betaVariance(alpha, beta) {
+  const n = alpha + beta;
+  return alpha * beta / (n * n * (n + 1));
+}
+function betaSd(alpha, beta) {
+  return Math.sqrt(betaVariance(alpha, beta));
+}
+function clamp01(x) {
+  if (x < 0) return 0;
+  if (x > 1) return 1;
+  return x;
+}
+function laplace(successes, total) {
+  return (successes + 1) / (total + 2);
+}
+function lift(q, b) {
+  if (q >= b) return b >= 1 ? 0 : (q - b) / (1 - b);
+  return b <= 0 ? 0 : (q - b) / b;
+}
+
+// src/intent.ts
+function priorCounts(intent) {
+  return {
+    alpha0: intent.prior * intent.priorStrength,
+    beta0: (1 - intent.prior) * intent.priorStrength
+  };
+}
+function initIntent(intent) {
+  const { alpha0, beta0 } = priorCounts(intent);
+  return {
+    alpha: alpha0,
+    beta: beta0,
+    updatedAt: null,
+    contributions: {},
+    learned: {},
+    episodes: { hits: 0, misses: 0 },
+    learnedAt: null,
+    lastRevealedAt: null,
+    lastOutcomeAt: null,
+    revealCount: 0
+  };
+}
+function withContributions(state, intent, contributions) {
+  const { alpha0, beta0 } = priorCounts(intent);
+  let alpha = alpha0;
+  let beta = beta0;
+  for (const c of Object.values(contributions)) {
+    alpha += c.alpha;
+    beta += c.beta;
+  }
+  return { ...state, alpha, beta, contributions };
+}
+function decayIntent(state, intent, at) {
+  if (state.updatedAt === null) return { ...state, updatedAt: at };
+  const d = decayFactor(at - state.updatedAt, intent.halfLife);
+  const updatedAt = Math.max(state.updatedAt, at);
+  if (d === 1) return updatedAt === state.updatedAt ? state : { ...state, updatedAt };
+  const contributions = mapRecord(state.contributions, (c) => ({
+    alpha: c.alpha * d,
+    beta: c.beta * d
+  }));
+  return withContributions({ ...state, updatedAt }, intent, contributions);
+}
+function applySignal(state, intent, signal, weight) {
+  const prev = getOwn(state.contributions, signal) ?? { alpha: 0, beta: 0 };
+  const next = weight >= 0 ? { alpha: prev.alpha + weight, beta: prev.beta } : { alpha: prev.alpha, beta: prev.beta - weight };
+  return withContributions(state, intent, { ...state.contributions, [signal]: next });
+}
+function resetToPrior(state, intent) {
+  return withContributions(state, intent, {});
+}
+
+// src/learning.ts
+var NONE = { hits: 0, misses: 0 };
+function decayLearned(state, learning, at) {
+  if (state.learnedAt === null) return { ...state, learnedAt: at };
+  const learnedAt = Math.max(state.learnedAt, at);
+  const d = learning.halfLife === null ? 1 : decayFactor(at - state.learnedAt, learning.halfLife);
+  if (d === 1) return learnedAt === state.learnedAt ? state : { ...state, learnedAt };
+  return {
+    ...state,
+    learnedAt,
+    learned: mapRecord(state.learned, (r) => ({ hits: r.hits * d, misses: r.misses * d })),
+    episodes: { hits: state.episodes.hits * d, misses: state.episodes.misses * d }
+  };
+}
+function signalWeights(state, intent, learning, signal) {
+  const initial = getOwn(intent.signals, signal);
+  if (initial === void 0) {
+    throw new RangeError(`oracular: ${JSON.stringify(signal)} is not a signal of this intent`);
+  }
+  const record2 = getOwn(state.learned, signal) ?? NONE;
+  const n = record2.hits + record2.misses;
+  const q = laplace(record2.hits, n);
+  const b = laplace(state.episodes.hits, state.episodes.hits + state.episodes.misses);
+  const learned = n === 0 ? 0 : learning.gain * Math.abs(initial) * lift(q, b);
+  const k = learning.priorEpisodes;
+  const effective = (k * initial + n * learned) / (k + n);
+  return { initial, learned, effective, hits: record2.hits, misses: record2.misses };
+}
+function recordEpisode(state, signals, outcome) {
+  const learned = { ...state.learned };
+  for (const signal of signals) {
+    const r = getOwn(learned, signal) ?? NONE;
+    learned[signal] = outcome ? { hits: r.hits + 1, misses: r.misses } : { hits: r.hits, misses: r.misses + 1 };
+  }
+  const episodes = outcome ? { hits: state.episodes.hits + 1, misses: state.episodes.misses } : { hits: state.episodes.hits, misses: state.episodes.misses + 1 };
+  return { ...state, learned, episodes };
+}
+
+// src/episode.ts
+function emptyEpisode() {
+  return { startedAt: null, lastEventAt: null, intents: {} };
+}
+function timedOutAt(episode, timeout, at) {
+  if (timeout === void 0 || episode.lastEventAt === null) return null;
+  return at - episode.lastEventAt > timeout ? episode.lastEventAt + timeout : null;
+}
+function extendEpisode(episode, at) {
+  return {
+    startedAt: episode.startedAt ?? at,
+    lastEventAt: episode.lastEventAt === null ? at : Math.max(episode.lastEventAt, at),
+    intents: episode.intents
+  };
+}
+function episodeRecord(episode, intent) {
+  return getOwn(episode.intents, intent) ?? { seen: [], resolved: false };
+}
+function markSeen(episode, intent, signal) {
+  const record2 = episodeRecord(episode, intent);
+  if (record2.seen.includes(signal)) return episode;
+  return {
+    ...episode,
+    intents: { ...episode.intents, [intent]: { ...record2, seen: [...record2.seen, signal] } }
+  };
+}
+function markResolved(episode, intent) {
+  return { ...episode, intents: { ...episode.intents, [intent]: { seen: [], resolved: true } } };
+}
+
+// src/version.ts
+var STATE_VERSION = 1;
+
+// src/state.ts
+function createState(config) {
+  const normalized = normalizeConfig(config);
+  const intents = {};
+  for (const [name, intent] of Object.entries(normalized.intents)) {
+    intents[name] = initIntent(intent);
+  }
+  return { version: STATE_VERSION, config: normalized, intents, episode: emptyEpisode() };
+}
+function requireState(state) {
+  if (!isRecord(state) || state.version !== STATE_VERSION || !isRecord(state.config) || !isRecord(state.intents) || !isRecord(state.episode)) {
+    throw new TypeError("oracular: state must be an EngineState from createState or deserialize");
+  }
+  return state;
+}
+function requireIntentConfig(state, name) {
+  const intent = getOwn(state.config.intents, name);
+  if (intent === void 0) {
+    throw new RangeError(`oracular: unknown intent ${JSON.stringify(name)}`);
+  }
+  return intent;
+}
+function getIntentState(state, name, intent) {
+  return getOwn(state.intents, name) ?? initIntent(intent);
+}
+
+// src/explain.ts
+function explain(state, intent, at) {
+  const s = requireState(state);
+  const name = expectName(intent, "intent");
+  const t = expectTimestamp(at, "at");
+  const config = requireIntentConfig(s, name);
+  const learning = resolveLearning(s.config);
+  let is = decayIntent(getIntentState(s, name, config), config, t);
+  is = decayLearned(is, learning, t);
+  const p = betaMean(is.alpha, is.beta);
+  const out = [];
+  for (const signal of Object.keys(config.signals)) {
+    const c = getOwn(is.contributions, signal) ?? { alpha: 0, beta: 0 };
+    const w = signalWeights(is, config, learning, signal);
+    const without = betaMean(is.alpha - c.alpha, is.beta - c.beta);
+    out.push({
+      signal,
+      contribution: c.alpha - c.beta,
+      impact: p - without,
+      initialWeight: w.initial,
+      learnedWeight: w.learned,
+      effectiveWeight: w.effective,
+      hits: w.hits,
+      misses: w.misses
+    });
+  }
+  out.sort((a, b) => Math.abs(b.impact) - Math.abs(a.impact) || compare(a.signal, b.signal));
+  return out;
+}
+function compare(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+// src/observe.ts
+function observe(state, event) {
+  let s = requireState(state);
+  const { name, at } = validateEvent(event);
+  const closeAt = timedOutAt(s.episode, s.config.episodeTimeout, at);
+  if (closeAt !== null) s = closeEpisode(s, closeAt);
+  const learning = resolveLearning(s.config);
+  const intents = { ...s.intents };
+  let episode = extendEpisode(s.episode, at);
+  for (const [intentName, intent] of Object.entries(s.config.intents)) {
+    const isSignal = hasOwn(intent.signals, name);
+    const isOutcome = intent.outcome === name;
+    if (!isSignal && !isOutcome) continue;
+    let is = getIntentState(s, intentName, intent);
+    is = decayIntent(is, intent, at);
+    is = decayLearned(is, learning, at);
+    if (isSignal) {
+      const { effective } = signalWeights(is, intent, learning, name);
+      is = applySignal(is, intent, name, effective);
+      if (!isOutcome) episode = markSeen(episode, intentName, name);
+    }
+    if (isOutcome) {
+      is = recordEpisode(is, episodeRecord(episode, intentName).seen, true);
+      episode = markResolved(episode, intentName);
+      is = { ...is, lastOutcomeAt: at };
+      if (intent.resetOnOutcome ?? true) is = resetToPrior(is, intent);
+    }
+    intents[intentName] = is;
+  }
+  return { ...s, intents, episode };
+}
+function endEpisode(state, at) {
+  const s = requireState(state);
+  const t = expectTimestamp(at, "at");
+  if (s.episode.startedAt === null) return s;
+  const closeAt = timedOutAt(s.episode, s.config.episodeTimeout, t);
+  return closeEpisode(s, closeAt ?? t);
+}
+function closeEpisode(state, at) {
+  const learning = resolveLearning(state.config);
+  const intents = { ...state.intents };
+  for (const [intentName, intent] of Object.entries(state.config.intents)) {
+    const record2 = episodeRecord(state.episode, intentName);
+    if (record2.resolved) continue;
+    let is = getIntentState(state, intentName, intent);
+    is = decayLearned(is, learning, at);
+    is = recordEpisode(is, record2.seen, false);
+    intents[intentName] = is;
+  }
+  return { ...state, intents, episode: emptyEpisode() };
+}
+
+// src/predict.ts
+function predict(state, intent, at, opts) {
+  const s = requireState(state);
+  const name = expectName(intent, "intent");
+  const t = expectTimestamp(at, "at");
+  const config = requireIntentConfig(s, name);
+  const reveal = resolveReveal(s.config, config, opts);
+  const is = decayIntent(getIntentState(s, name, config), config, t);
+  const p = betaMean(is.alpha, is.beta);
+  const sd = betaSd(is.alpha, is.beta);
+  const revealEnd = cooldownEnd(is.lastRevealedAt, reveal.cooldown, t);
+  const outcomeEnd = cooldownEnd(is.lastOutcomeAt, reveal.cooldown, t);
+  const suppressedUntil = revealEnd === null ? outcomeEnd : outcomeEnd === null ? revealEnd : Math.max(revealEnd, outcomeEnd);
+  return {
+    intent: name,
+    p,
+    sd,
+    lower: clamp01(p - reveal.z * sd),
+    confidence: clamp01(1 - 2 * sd),
+    evidence: is.alpha + is.beta,
+    revealed: revealEnd !== null,
+    revealedAt: is.lastRevealedAt,
+    suppressedUntil
+  };
+}
+function cooldownEnd(since, cooldown, at) {
+  if (since === null) return null;
+  const end = since + cooldown;
+  return at < end ? end : null;
+}
+function shouldReveal(state, intent, at, opts) {
+  const s = requireState(state);
+  const name = expectName(intent, "intent");
+  const config = requireIntentConfig(s, name);
+  const { threshold } = resolveReveal(s.config, config, opts);
+  const prediction = predict(s, name, at, opts);
+  return prediction.suppressedUntil === null && prediction.p >= threshold && prediction.lower >= threshold;
+}
+function markRevealed(state, intent, at) {
+  const s = requireState(state);
+  const name = expectName(intent, "intent");
+  const t = expectTimestamp(at, "at");
+  const config = requireIntentConfig(s, name);
+  const is = getIntentState(s, name, config);
+  return {
+    ...s,
+    intents: {
+      ...s.intents,
+      [name]: { ...is, lastRevealedAt: t, revealCount: is.revealCount + 1 }
+    }
+  };
+}
+
+// src/serialize.ts
+function serialize(state) {
+  return JSON.stringify(requireState(state));
+}
+function deserialize(json, opts = {}) {
+  if (typeof json !== "string") throw new TypeError("oracular: deserialize expects a JSON string");
+  if (!isRecord(opts)) throw new TypeError("oracular: options must be a plain object");
+  for (const key of Object.keys(opts)) {
+    if (key !== "config" && key !== "migrate") {
+      throw new TypeError(
+        `oracular: options.${key} is not a recognised option (expected one of: config, migrate)`
+      );
+    }
+  }
+  if (opts.migrate !== void 0 && typeof opts.migrate !== "function") {
+    throw new TypeError("oracular: options.migrate must be a function");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (error) {
+    throw new SyntaxError(`oracular: stored state is not valid JSON (${error.message})`);
+  }
+  if (!isRecord(parsed) || typeof parsed.version !== "number") {
+    throw new TypeError("oracular: stored state has no numeric version field");
+  }
+  let stored = parsed;
+  if (parsed.version !== STATE_VERSION) {
+    if (opts.migrate === void 0) {
+      throw new RangeError(
+        `oracular: stored state is version ${parsed.version} but this library reads version ${STATE_VERSION}; pass a migrate function`
+      );
+    }
+    stored = opts.migrate(parsed, parsed.version);
+  }
+  const raw = parseState(stored);
+  const config = opts.config === void 0 ? raw.config : normalizeConfig(opts.config);
+  return reconcile(raw, config);
+}
+function typeError2(path, message) {
+  throw new TypeError(`oracular: ${path} ${message}`);
+}
+function record(value, path) {
+  if (!isRecord(value)) typeError2(path, "must be a plain object");
+  return value;
+}
+function finite(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    typeError2(path, "must be a finite number");
+  return value;
+}
+function nonNegative(value, path) {
+  const n = finite(value, path);
+  if (n < 0) throw new RangeError(`oracular: ${path} must be 0 or greater`);
+  return n;
+}
+function nullOrFinite(value, path) {
+  return value === null ? null : finite(value, path);
+}
+function signalRecord(value, path) {
+  const r = record(value, path);
+  return {
+    hits: nonNegative(r.hits, `${path}.hits`),
+    misses: nonNegative(r.misses, `${path}.misses`)
+  };
+}
+function contribution(value, path) {
+  const r = record(value, path);
+  return {
+    alpha: nonNegative(r.alpha, `${path}.alpha`),
+    beta: nonNegative(r.beta, `${path}.beta`)
+  };
+}
+function mapOwn(value, path, fn) {
+  const r = record(value, path);
+  const out = {};
+  for (const key of Object.keys(r)) {
+    if (key === "__proto__") continue;
+    out[key] = fn(r[key], `${path}[${JSON.stringify(key)}]`);
+  }
+  return out;
+}
+function intentState(value, path) {
+  const r = record(value, path);
+  const revealCount = finite(r.revealCount, `${path}.revealCount`);
+  if (!Number.isInteger(revealCount) || revealCount < 0) {
+    throw new RangeError(`oracular: ${path}.revealCount must be a non-negative integer`);
+  }
+  return {
+    alpha: finite(r.alpha, `${path}.alpha`),
+    beta: finite(r.beta, `${path}.beta`),
+    updatedAt: nullOrFinite(r.updatedAt, `${path}.updatedAt`),
+    contributions: mapOwn(r.contributions, `${path}.contributions`, contribution),
+    learned: mapOwn(r.learned, `${path}.learned`, signalRecord),
+    episodes: signalRecord(r.episodes, `${path}.episodes`),
+    learnedAt: nullOrFinite(r.learnedAt, `${path}.learnedAt`),
+    lastRevealedAt: nullOrFinite(r.lastRevealedAt, `${path}.lastRevealedAt`),
+    lastOutcomeAt: nullOrFinite(r.lastOutcomeAt, `${path}.lastOutcomeAt`),
+    revealCount
+  };
+}
+function episodeIntent(value, path) {
+  const r = record(value, path);
+  if (!Array.isArray(r.seen) || !r.seen.every((s) => typeof s === "string")) {
+    typeError2(`${path}.seen`, "must be an array of strings");
+  }
+  if (typeof r.resolved !== "boolean") typeError2(`${path}.resolved`, "must be a boolean");
+  return { seen: r.seen, resolved: r.resolved };
+}
+function episodeState(value, path) {
+  const r = record(value, path);
+  return {
+    startedAt: nullOrFinite(r.startedAt, `${path}.startedAt`),
+    lastEventAt: nullOrFinite(r.lastEventAt, `${path}.lastEventAt`),
+    intents: mapOwn(r.intents, `${path}.intents`, episodeIntent)
+  };
+}
+function parseState(value) {
+  const r = record(value, "state");
+  if (r.version !== STATE_VERSION) {
+    throw new RangeError(`oracular: state.version must be ${STATE_VERSION} after migration`);
+  }
+  return {
+    version: STATE_VERSION,
+    config: normalizeConfig(r.config),
+    intents: mapOwn(r.intents, "state.intents", intentState),
+    episode: episodeState(r.episode, "state.episode")
+  };
+}
+function keep(source, declared) {
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (hasOwn(declared, key)) out[key] = value;
+  }
+  return out;
+}
+function reconcile(raw, config) {
+  const intents = {};
+  const episodeIntents = {};
+  for (const [name, intent] of Object.entries(config.intents)) {
+    const stored = getOwn(raw.intents, name);
+    if (stored === void 0) {
+      intents[name] = initIntent(intent);
+    } else {
+      intents[name] = withContributions(
+        { ...stored, learned: keep(stored.learned, intent.signals) },
+        intent,
+        keep(stored.contributions, intent.signals)
+      );
+    }
+    const episode = getOwn(raw.episode.intents, name);
+    if (episode !== void 0 && raw.episode.startedAt !== null) {
+      const seen = episode.seen.filter(
+        (s, i) => hasOwn(intent.signals, s) && episode.seen.indexOf(s) === i
+      );
+      episodeIntents[name] = { seen, resolved: episode.resolved };
+    }
+  }
+  return {
+    version: STATE_VERSION,
+    config,
+    intents,
+    episode: {
+      startedAt: raw.episode.startedAt,
+      lastEventAt: raw.episode.startedAt === null ? null : raw.episode.lastEventAt,
+      intents: episodeIntents
+    }
+  };
+}
+
+export { STATE_VERSION, createState, deserialize, endEpisode, explain, markRevealed, observe, predict, serialize, shouldReveal };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map