@validation-os/core 0.5.0 → 0.6.0

package/dist/chunk-22WJF5EZ.js

@@ -0,0 +1,572 @@
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/derivation/index.ts
+var derivation_exports = {};
+__export(derivation_exports, {
+  COMPLETENESS_SLOTS: () => COMPLETENESS_SLOTS,
+  KILL_LANE_THRESHOLD: () => KILL_LANE_THRESHOLD,
+  MARKET_RUNG_ANCHOR: () => MARKET_RUNG_ANCHOR,
+  RUNG_ANCHOR: () => RUNG_ANCHOR,
+  W0: () => W0,
+  assembleJourney: () => assembleJourney,
+  assumptionComplete: () => assumptionComplete,
+  assumptionCompleteness: () => assumptionCompleteness,
+  beliefRisk: () => beliefRisk,
+  beliefTestMeters: () => beliefTestMeters,
+  classifyStage: () => classifyStage,
+  completenessSlotPresence: () => completenessSlotPresence,
+  confidence: () => confidence,
+  confidenceAttribution: () => confidenceAttribution,
+  confidenceTrajectory: () => confidenceTrajectory,
+  deriveBeliefStage: () => deriveBeliefStage,
+  derivedImpacts: () => derivedImpacts,
+  emptyTestMeter: () => emptyTestMeter,
+  experimentProgress: () => experimentProgress,
+  isConcluded: () => isConcluded,
+  isMarketRung: () => isMarketRung,
+  missingCompletenessSlots: () => missingCompletenessSlots,
+  portfolioProgress: () => portfolioProgress,
+  rankNextMoves: () => rankNextMoves,
+  readingStrength: () => readingStrength,
+  risk: () => risk,
+  round2: () => round2,
+  scoreAndDedupe: () => scoreAndDedupe,
+  sign: () => sign,
+  sourceQuality: () => sourceQuality
+});
+
+// src/derivation/round.ts
+function round2(n) {
+  return Number(n.toFixed(2));
+}
+
+// src/types.ts
+var REGISTERS = [
+  "assumptions",
+  "experiments",
+  "readings",
+  "decisions",
+  "glossary"
+];
+var TESTING_RUNGS = [
+  "Opinion",
+  "Pitch-deck reaction",
+  "Anecdotal",
+  "Desk research",
+  "Survey at scale",
+  "Prototype usage"
+];
+var MARKET_RUNG_VALUES = ["Signed intent", "Paying users"];
+
+// src/derivation/rung.ts
+var RUNG_ANCHOR = {
+  Opinion: 3,
+  "Pitch-deck reaction": 6,
+  Anecdotal: 10,
+  "Desk research": 15,
+  "Survey at scale": 25,
+  "Prototype usage": 30
+};
+var MARKET_RUNG_ANCHOR = {
+  "Signed intent": { Low: 55, Typical: 68, High: 80 },
+  "Paying users": { Low: 75, Typical: 88, High: 99 }
+};
+var MARKET_RUNG_SET = new Set(MARKET_RUNG_VALUES);
+function isMarketRung(rung) {
+  return MARKET_RUNG_SET.has(rung);
+}
+
+// src/derivation/completeness.ts
+var COMPLETENESS_SLOTS = [
+  "Description",
+  "Lens",
+  "Impact",
+  "Scoring justification",
+  "Dependencies traced"
+];
+function hasText(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function hasNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function hasAny(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+function completenessSlotPresence(record) {
+  return {
+    Description: hasText(record.Description),
+    Lens: hasText(record.Lens),
+    Impact: hasNumber(record.Impact),
+    "Scoring justification": hasText(record["Scoring justification"]),
+    "Dependencies traced": hasAny(record.dependsOnIds) || hasAny(record.enablesIds)
+  };
+}
+function missingCompletenessSlots(record) {
+  const present = completenessSlotPresence(record);
+  return COMPLETENESS_SLOTS.filter((slot) => !present[slot]);
+}
+function assumptionCompleteness(record) {
+  const present = completenessSlotPresence(record);
+  const filled = COMPLETENESS_SLOTS.filter((slot) => present[slot]).length;
+  return Math.round(filled / COMPLETENESS_SLOTS.length * 100);
+}
+function assumptionComplete(record) {
+  return missingCompletenessSlots(record).length === 0;
+}
+
+// src/derivation/strength.ts
+function sign(result) {
+  if (result === "Validated") return 1;
+  if (result === "Invalidated") return -1;
+  return 0;
+}
+function isConcluded(result) {
+  return result === "Validated" || result === "Invalidated";
+}
+function readingStrength(input) {
+  const s = sign(input.result);
+  if (s === 0) return 0;
+  if (isMarketRung(input.rung)) {
+    const band = input.magnitudeBand ?? "Typical";
+    return MARKET_RUNG_ANCHOR[input.rung][band] * s;
+  }
+  return (RUNG_ANCHOR[input.rung] ?? 0) * s;
+}
+
+// src/derivation/source-quality.ts
+function sourceQuality(representativeness, credibility) {
+  return round2(representativeness * credibility);
+}
+
+// src/derivation/confidence.ts
+var W0 = 100;
+function scoreAndDedupe(readings) {
+  const scored = readings.filter((r) => isConcluded(r.result)).map((r) => {
+    const strength = readingStrength(r);
+    const sq = sourceQuality(r.representativeness, r.credibility);
+    return { input: r, strength, sq, weight: Math.abs(strength) * sq };
+  }).filter((x) => x.strength !== 0);
+  const best = /* @__PURE__ */ new Map();
+  for (const x of scored) {
+    if (isMarketRung(x.input.rung)) {
+      best.set(x.input.id, x);
+      continue;
+    }
+    const key = x.input.source || x.input.id;
+    const cur = best.get(key);
+    const better = !cur || Math.abs(x.strength) > Math.abs(cur.strength) || Math.abs(x.strength) === Math.abs(cur.strength) && (x.input.date || "") > (cur.input.date || "");
+    if (better) best.set(key, x);
+  }
+  return [...best.values()];
+}
+function confidence(readings) {
+  const winners = scoreAndDedupe(readings);
+  let num = 0;
+  let den = W0;
+  for (const x of winners) {
+    num += x.weight * x.strength;
+    den += x.weight;
+  }
+  return den > 0 ? round2(num / den) : 0;
+}
+
+// src/derivation/attribution.ts
+function bucketOf(r) {
+  if (r.experimentId) {
+    return {
+      key: r.experimentId,
+      kind: "experiment",
+      experimentId: r.experimentId
+    };
+  }
+  return { key: "direct", kind: "direct", experimentId: null };
+}
+function confidenceAttribution(readings) {
+  const winners = scoreAndDedupe(readings);
+  const den = winners.reduce((acc, x) => acc + x.weight, W0);
+  const byKey = /* @__PURE__ */ new Map();
+  let num = 0;
+  for (const x of winners) {
+    num += x.weight * x.strength;
+    const b = bucketOf(x.input);
+    const contribution = x.weight * x.strength / den;
+    const cur = byKey.get(b.key);
+    if (cur) {
+      cur.contribution += contribution;
+      cur.readingCount += 1;
+      cur.readingIds.push(x.input.id);
+    } else {
+      byKey.set(b.key, {
+        key: b.key,
+        kind: b.kind,
+        experimentId: b.experimentId,
+        contribution,
+        magnitude: 0,
+        // finalised below
+        readingCount: 1,
+        readingIds: [x.input.id]
+      });
+    }
+  }
+  const movers = [...byKey.values()].map((m) => ({
+    ...m,
+    contribution: round2(m.contribution),
+    magnitude: round2(Math.abs(m.contribution))
+  }));
+  movers.sort((a, b) => b.magnitude - a.magnitude);
+  return {
+    confidence: den > 0 ? round2(num / den) : 0,
+    movers
+  };
+}
+
+// src/derivation/progress.ts
+function experimentProgress(bars) {
+  const total = bars.length;
+  const settled = bars.filter(
+    (b) => typeof b.barVerdict === "string" && b.barVerdict.trim() !== ""
+  ).length;
+  return {
+    total,
+    settled,
+    toGo: total - settled,
+    concluded: total > 0 && settled === total
+  };
+}
+
+// src/derivation/trajectory.ts
+function confidenceTrajectory(readings) {
+  const concluded = readings.filter((r) => isConcluded(r.result));
+  const undated = concluded.filter((r) => !r.date);
+  const dated = concluded.filter((r) => r.date);
+  if (dated.length === 0) return [];
+  const dates = [...new Set(dated.map((r) => r.date))].sort();
+  return dates.map((date) => ({
+    date,
+    // Everything dated on/before this point, plus the always-present undated.
+    confidence: confidence([
+      ...undated,
+      ...dated.filter((r) => r.date <= date)
+    ])
+  }));
+}
+
+// src/derivation/impact.ts
+function derivedImpacts(assumptions, basedOnCounts = {}) {
+  const byId = new Map(assumptions.map((a) => [a.id, a]));
+  const dependents = /* @__PURE__ */ new Map();
+  for (const a of assumptions) dependents.set(a.id, []);
+  for (const a of assumptions) {
+    for (const dep of a.dependsOnIds) dependents.get(dep)?.push(a.id);
+  }
+  const memo = /* @__PURE__ */ new Map();
+  const compute = (id, seen) => {
+    const cached = memo.get(id);
+    if (cached !== void 0) return cached;
+    if (seen.has(id)) return 0;
+    seen.add(id);
+    const a = byId.get(id);
+    if (!a) return 0;
+    if (a.moot) {
+      memo.set(id, 0);
+      return 0;
+    }
+    const seed = a.impact ?? 0;
+    let S = 0;
+    for (const depId of dependents.get(id) ?? []) {
+      const d = byId.get(depId);
+      if (d && !d.moot) S += compute(depId, seen);
+    }
+    S += 100 * (basedOnCounts[id] ?? 0);
+    const value = seed + (100 - seed) * (S / (S + 100));
+    const rounded = round2(value);
+    memo.set(id, rounded);
+    return rounded;
+  };
+  const out = /* @__PURE__ */ new Map();
+  for (const a of assumptions) out.set(a.id, compute(a.id, /* @__PURE__ */ new Set()));
+  return out;
+}
+
+// src/derivation/risk.ts
+function risk(derivedImpact, confidence2) {
+  return round2(derivedImpact * (1 - Math.max(0, confidence2) / 100));
+}
+
+// src/derivation/portfolio.ts
+function beliefRisk(b) {
+  const seed = b.seedImpact ?? 0;
+  const identified = Math.max(b.derivedImpact, seed, 0);
+  const live = b.resolved ? 0 : Math.min(identified, Math.max(0, b.risk));
+  return {
+    identified: round2(identified),
+    live: round2(live),
+    retired: round2(identified - live)
+  };
+}
+function portfolioProgress(beliefs) {
+  let identified = 0;
+  let live = 0;
+  let liveCount = 0;
+  let resolvedCount = 0;
+  for (const b of beliefs) {
+    const r = beliefRisk(b);
+    identified += r.identified;
+    live += r.live;
+    if (b.resolved) resolvedCount += 1;
+    else liveCount += 1;
+  }
+  const retired = identified - live;
+  return {
+    identified: round2(identified),
+    retired: round2(retired),
+    live: round2(live),
+    percent: identified > 0 ? round2(retired / identified * 100) : 0,
+    liveCount,
+    resolvedCount
+  };
+}
+
+// src/derivation/next-move.ts
+var KILL_LANE_THRESHOLD = -50;
+var FEASIBILITY_WEIGHT = {
+  High: 1,
+  Medium: 0.6,
+  Low: 0.3
+};
+var NEUTRAL_FEASIBILITY_WEIGHT = FEASIBILITY_WEIGHT.Medium;
+function isStanding(decisionStatus) {
+  return decisionStatus === "Active" || decisionStatus === "Provisional";
+}
+function bestFeasibility(feasibilities) {
+  let best = null;
+  let bestWeight = -1;
+  for (const f of feasibilities) {
+    if (!f) continue;
+    const w = FEASIBILITY_WEIGHT[f];
+    if (w > bestWeight) {
+      bestWeight = w;
+      best = f;
+    }
+  }
+  return best;
+}
+function stageMove(a, hasRunningTest, hasAnyTest, hasStandingDecision) {
+  if (a.impact === null) return "score-impact";
+  if (a.concludedReadings === 0) {
+    return hasRunningTest ? "record-reading" : "design-experiment";
+  }
+  if (!hasStandingDecision) return "decide";
+  return null;
+}
+function reasonFor(move, a) {
+  switch (move) {
+    case "retest":
+      return `Confidence has fallen to ${Math.round(a.confidence)} \u2014 the evidence is turning against this belief. Kill it or test it again.`;
+    case "score-impact":
+      return "This belief isn't weighted yet \u2014 score its impact so its risk can rank against the rest.";
+    case "design-experiment":
+      return `Your riskiest untested belief. Design the cheapest honest test that could move it.`;
+    case "record-reading":
+      return "A test is running against this belief \u2014 evidence is still landing.";
+    case "decide":
+      return "The evidence is in and nothing rests on it yet \u2014 time to make the call.";
+  }
+}
+function rankNextMoves(input) {
+  const { assumptions, experiments, decisions } = input;
+  const testsByAssumption = /* @__PURE__ */ new Map();
+  for (const exp of experiments) {
+    const running = exp.status === "Running";
+    for (const id of exp.assumptionIds) {
+      const entry = testsByAssumption.get(id) ?? {
+        running: false,
+        any: false,
+        feasibilities: []
+      };
+      entry.any = true;
+      entry.running = entry.running || running;
+      entry.feasibilities.push(exp.feasibility);
+      testsByAssumption.set(id, entry);
+    }
+  }
+  const decidedAssumptions = /* @__PURE__ */ new Set();
+  for (const d of decisions) {
+    if (!isStanding(d.status)) continue;
+    for (const id of d.assumptionIds) decidedAssumptions.add(id);
+  }
+  const moves = [];
+  for (const a of assumptions) {
+    if (a.moot || a.status === "Invalidated") continue;
+    const killLane = a.confidence <= KILL_LANE_THRESHOLD;
+    const tests = testsByAssumption.get(a.id);
+    const feasibility = bestFeasibility(tests?.feasibilities ?? []);
+    const move = killLane ? "retest" : stageMove(
+      a,
+      tests?.running ?? false,
+      tests?.any ?? false,
+      decidedAssumptions.has(a.id)
+    );
+    if (move === null) continue;
+    const weight = feasibility ? FEASIBILITY_WEIGHT[feasibility] : NEUTRAL_FEASIBILITY_WEIGHT;
+    const score = round2(killLane ? a.risk : weight * a.risk);
+    moves.push({
+      move,
+      assumptionId: a.id,
+      title: a.title,
+      score,
+      reason: reasonFor(move, a),
+      risk: a.risk,
+      confidence: a.confidence,
+      feasibility,
+      killLane
+    });
+  }
+  moves.sort((x, y) => {
+    if (x.killLane !== y.killLane) return x.killLane ? -1 : 1;
+    if (y.score !== x.score) return y.score - x.score;
+    if (x.confidence !== y.confidence) return x.confidence - y.confidence;
+    return x.assumptionId < y.assumptionId ? -1 : 1;
+  });
+  return moves;
+}
+
+// src/derivation/stage.ts
+function emptyTestMeter() {
+  return { planned: false, settled: 0, total: 0 };
+}
+function beliefTestMeters(experiments) {
+  const byAssumption = /* @__PURE__ */ new Map();
+  const ensure = (id) => {
+    let s = byAssumption.get(id);
+    if (!s) {
+      s = emptyTestMeter();
+      byAssumption.set(id, s);
+    }
+    return s;
+  };
+  for (const exp of experiments) {
+    for (const b of exp.bars) {
+      if (!b.assumptionId) continue;
+      const s = ensure(b.assumptionId);
+      s.planned = true;
+      s.total += 1;
+      if (b.settled) s.settled += 1;
+    }
+    for (const id of exp.plannedAssumptionIds) ensure(id).planned = true;
+  }
+  return byAssumption;
+}
+function classifyStage(framed, test) {
+  if (framed < 100) return "framed";
+  if (!test.planned) return "planned";
+  if (test.total === 0 || test.settled < test.total) return "tested";
+  return "known";
+}
+function deriveBeliefStage(input) {
+  const { framed, confidence: confidence2, test } = input;
+  return {
+    stage: classifyStage(framed, test),
+    framed,
+    planned: test.planned,
+    tested: { settled: test.settled, total: test.total },
+    confidence: confidence2,
+    confSign: confidence2 > 0 ? "pos" : confidence2 < 0 ? "neg" : "zero",
+    killZone: confidence2 <= KILL_LANE_THRESHOLD
+  };
+}
+
+// src/derivation/journey.ts
+var KIND_ORDER = {
+  bet: 0,
+  score: 1,
+  experiment: 2,
+  reading: 3,
+  "confidence-cross": 4,
+  now: 5
+};
+function assembleJourney(input) {
+  const { belief, readings, experiments, now } = input;
+  const events = [];
+  if (belief.createdAt) {
+    events.push(event("bet", belief.createdAt));
+  }
+  if (belief.impactScored) {
+    events.push(event("score", null));
+  }
+  for (const e of experiments) {
+    events.push(event("experiment", e.date, { refId: e.id }));
+  }
+  const trajectory = confidenceTrajectory(readings);
+  const confByDate = new Map(trajectory.map((p) => [p.date, p.confidence]));
+  for (const r of readings) {
+    const dated = r.date ?? null;
+    const conf = dated && isConcluded(r.result) ? confByDate.get(dated) ?? null : null;
+    events.push(
+      event("reading", dated, { confidence: conf, result: r.result, refId: r.id })
+    );
+  }
+  const cross = trajectory.find((p) => p.confidence <= KILL_LANE_THRESHOLD);
+  if (cross) {
+    events.push(event("confidence-cross", cross.date, { confidence: cross.confidence }));
+  }
+  const anchor = belief.createdAt ?? "";
+  events.sort((a, b) => {
+    const ka = a.date ?? anchor;
+    const kb = b.date ?? anchor;
+    if (ka !== kb) return ka < kb ? -1 : 1;
+    return KIND_ORDER[a.kind] - KIND_ORDER[b.kind];
+  });
+  events.push(event("now", now, { confidence: confidence(readings) }));
+  return events;
+}
+function event(kind, date, extra = {}) {
+  return {
+    kind,
+    date,
+    confidence: extra.confidence ?? null,
+    result: extra.result ?? null,
+    refId: extra.refId ?? null
+  };
+}
+
+export {
+  REGISTERS,
+  TESTING_RUNGS,
+  MARKET_RUNG_VALUES,
+  COMPLETENESS_SLOTS,
+  completenessSlotPresence,
+  missingCompletenessSlots,
+  assumptionCompleteness,
+  assumptionComplete,
+  round2,
+  RUNG_ANCHOR,
+  MARKET_RUNG_ANCHOR,
+  isMarketRung,
+  sign,
+  isConcluded,
+  readingStrength,
+  sourceQuality,
+  W0,
+  scoreAndDedupe,
+  confidence,
+  confidenceAttribution,
+  experimentProgress,
+  confidenceTrajectory,
+  derivedImpacts,
+  risk,
+  beliefRisk,
+  portfolioProgress,
+  KILL_LANE_THRESHOLD,
+  rankNextMoves,
+  emptyTestMeter,
+  beliefTestMeters,
+  classifyStage,
+  deriveBeliefStage,
+  assembleJourney,
+  derivation_exports
+};
+//# sourceMappingURL=chunk-22WJF5EZ.js.map