@bitflow/core 0.5.4 → 0.7.0

package/dist/index.js

@@ -0,0 +1,1410 @@
+import { z as o } from "zod";
+const rt = [
+  "INVALID_FLOW",
+  "INVALID_ATTEMPT",
+  "FLOW_ATTEMPT_MISMATCH",
+  "UNKNOWN_BIT_TYPE",
+  "LOAD_FAILED",
+  "EVALUATION_FAILED"
+], w = (e, t, n) => n && n.length > 0 ? { code: e, message: t, diagnostics: n } : { code: e, message: t }, _ = (e) => e.map((t) => ({
+  path: t.path.map(String).join("."),
+  message: t.message
+})), Y = (e) => e.score ? e.score : e.state === "unknown" ? { earned: 0, possible: 0 } : { earned: e.state === "correct" ? 1 : 0, possible: 1 }, j = (e) => {
+  let t = 0, n = 0;
+  for (const s of e) {
+    const r = Y(s);
+    t += r.earned, n += r.possible;
+  }
+  return { earned: t, possible: n };
+}, V = (e, t) => {
+  if (!t) return e;
+  let n = e;
+  for (const s of t.split(".")) {
+    if (n == null || typeof n != "object") return;
+    n = n[s];
+  }
+  return n;
+}, ce = (e, t) => {
+  if (e)
+    switch (e.kind) {
+      case "nodes":
+        return e.nodeIds;
+      case "section":
+        return Object.keys(t.sections).filter(
+          (n) => t.sections[n] === e.id
+        );
+      case "last": {
+        const n = [];
+        for (let s = t.history.length - 1; s >= 0 && n.length < e.count; s--) {
+          const r = t.history[s];
+          n.includes(r) || r in t.results && n.push(r);
+        }
+        return n;
+      }
+    }
+}, M = (e, t) => {
+  const n = ce(e, t);
+  return n ? n.map((s) => t.results[s]).filter((s) => s !== void 0) : Object.values(t.results);
+}, le = (e, t) => {
+  switch (e.kind) {
+    case "answer":
+      return V(t.answers[e.nodeId], e.path);
+    case "result":
+      return V(t.results[e.nodeId], e.path);
+    case "tries":
+      return t.tries[e.nodeId] ?? 0;
+    case "visits":
+      return t.visits[e.nodeId] ?? 0;
+    case "confidence":
+      return t.confidence[e.nodeId];
+    case "timeSpent":
+      return e.nodeId === void 0 ? t.totalTimeSpent : t.timeSpent[e.nodeId] ?? 0;
+    case "timeRemaining":
+      return t.timeRemaining ?? void 0;
+    case "score":
+      return j(M(e.scope, t)).earned;
+    case "scoreRatio": {
+      const n = j(M(e.scope, t));
+      return n.possible === 0 ? 0 : n.earned / n.possible;
+    }
+    case "resultCount":
+      return M(e.scope, t).filter(
+        (n) => n.state === e.state
+      ).length;
+  }
+}, W = (e) => typeof e == "number" ? e : Number(e), $ = (e, t) => {
+  switch (e.type) {
+    case "always":
+      return !0;
+    case "not":
+      return !$(e.condition, t);
+    case "and":
+      return e.conditions.every((n) => $(n, t));
+    case "or":
+      return e.conditions.some((n) => $(n, t));
+    case "compare":
+      return ue(
+        le(e.left, t),
+        e.op,
+        e.right
+      );
+  }
+}, ue = (e, t, n) => {
+  switch (t) {
+    case "isTrue":
+      return e === !0;
+    case "eq":
+      return e === n;
+    case "ne":
+      return e !== n;
+    case "in":
+      return Array.isArray(n) ? n.includes(e) : !1;
+    case "notIn":
+      return Array.isArray(n) ? !n.includes(e) : !1;
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      if (e == null) return !1;
+      const s = W(e), r = W(n);
+      return Number.isNaN(s) || Number.isNaN(r) ? !1 : t === "gt" ? s > r : t === "gte" ? s >= r : t === "lt" ? s < r : s <= r;
+    }
+    default:
+      return !1;
+  }
+}, L = (e) => {
+  switch (e.type) {
+    case "always":
+      return [];
+    case "not":
+      return L(e.condition);
+    case "and":
+    case "or":
+      return e.conditions.flatMap(L);
+    case "compare": {
+      const { left: t } = e;
+      return "nodeId" in t && t.nodeId !== void 0 ? [t.nodeId] : "scope" in t && t.scope?.kind === "nodes" ? t.scope.nodeIds : [];
+    }
+  }
+}, U = (e) => {
+  switch (e.type) {
+    case "always":
+      return [];
+    case "not":
+      return U(e.condition);
+    case "and":
+    case "or":
+      return e.conditions.flatMap(U);
+    case "compare": {
+      const { left: t } = e;
+      return "scope" in t && t.scope?.kind === "section" ? [t.scope.id] : [];
+    }
+  }
+}, it = ["start", "content", "task", "end"], I = /* @__PURE__ */ new Map(), at = (e) => {
+  I.set(e.type, e);
+}, b = (e) => I.get(e), ct = (e) => I.has(e), de = () => Array.from(I.values()), lt = () => {
+  I.clear();
+}, p = (e, t) => e.nodes.find((n) => n.id === t), q = (e, t) => {
+  const n = +!!t.condition - +!!e.condition;
+  if (n !== 0) return n;
+  const s = (e.sourceHandle ?? "").localeCompare(t.sourceHandle ?? "");
+  return s !== 0 ? s : e.id.localeCompare(t.id);
+}, k = (e, t) => e.edges.filter((n) => n.source === t).sort(q), C = (e, t) => e.edges.filter((n) => n.target === t), fe = (e) => {
+  const t = e.nodes.find((s) => b(s.type)?.kind === "start");
+  return t ? t.id : (e.nodes.find((s) => C(e, s.id).length === 0) ?? e.nodes[0])?.id;
+}, G = (e, t) => e.nodes.filter((n) => n.pool === t), me = (e, t = Math.random) => {
+  const n = {};
+  for (const s of e.meta.pools)
+    n[s.id] = he(
+      G(e, s.id).map((r) => r.id),
+      t
+    ).slice(0, s.draw);
+  return n;
+}, he = (e, t) => {
+  const n = [...e];
+  for (let s = n.length - 1; s > 0; s--) {
+    const r = Math.floor(t() * (s + 1));
+    [n[s], n[r]] = [n[r], n[s]];
+  }
+  return n;
+}, K = (e, t) => {
+  if (!t?.pool) return !0;
+  const n = e.pools[t.pool];
+  return n === void 0 || n.includes(t.id);
+}, Q = (e, t) => {
+  const n = p(e, t);
+  return !n || b(n.type)?.kind === "end" ? !0 : k(e, t).length === 0;
+}, X = (e, t) => {
+  if (!t?.pool) return;
+  const n = e.meta.pools.find((s) => s.id === t.pool);
+  return n?.shuffle ? n : void 0;
+}, Z = (e, t) => e.edges.filter((n) => {
+  const s = p(e, n.source), r = p(e, n.target);
+  return s?.pool === t && r !== void 0 && r.pool !== t;
+}).sort(q), x = (e, t, n, s = {}) => {
+  const { isActive: r = () => !0, order: i = {} } = s;
+  let a = t;
+  for (let u = 0; u <= e.nodes.length; u++) {
+    const f = p(e, a);
+    if (!f || b(f.type)?.kind === "end") return null;
+    const d = pe(e, f, n, i);
+    if (d === null) return null;
+    const h = ge(e, f, d, i), T = p(e, h.nodeId);
+    if (T && r(T)) return h;
+    a = h.nodeId;
+  }
+  return null;
+}, ut = (e, t, n, s = () => !0, r = {}) => x(e, t, n, { isActive: s, order: r })?.nodeId ?? null, pe = (e, t, n, s) => {
+  const r = X(e, t), i = r ? s[r.id] ?? [] : [];
+  if (r && i.length > 0) {
+    const a = i.indexOf(t.id);
+    return a >= 0 && a + 1 < i.length ? { nodeId: i[a + 1] } : H(e, Z(e, r.id), n);
+  }
+  return H(e, k(e, t.id), n);
+}, ge = (e, t, n, s) => {
+  const r = X(e, p(e, n.nodeId));
+  if (!r || t.pool === r.id) return n;
+  const i = s[r.id] ?? [];
+  return i.length === 0 ? n : { ...n, nodeId: i[0] };
+}, H = (e, t, n) => {
+  for (const s of t)
+    if ((!s.condition || $(s.condition, n)) && p(e, s.target))
+      return { nodeId: s.target, edge: s };
+  return null;
+}, ee = (e) => {
+  const { history: t } = e;
+  return t.length >= 2 ? t[t.length - 2] : null;
+}, dt = (e, t) => {
+  const n = [], s = /* @__PURE__ */ new Set();
+  for (const r of t.history) {
+    if (s.has(r)) continue;
+    s.add(r);
+    const i = p(e, r);
+    if (!i) continue;
+    const a = b(i.type)?.kind === "task", u = t.results[r] !== void 0;
+    n.push({
+      nodeId: r,
+      node: i,
+      position: n.length + 1,
+      current: r === t.currentNodeId,
+      answered: a && u,
+      outstanding: a && !u,
+      section: be(e, i)
+    });
+  }
+  return n;
+}, we = (e, t, n) => e.meta.navigation === "free" && t.history.includes(n) && p(e, n) !== void 0, be = (e, t) => t?.section ? e.meta.sections.find((n) => n.id === t.section) : void 0, ye = (e, t) => e.nodes.filter((n) => n.section === t), ft = (e, t) => {
+  const n = t?.data?.evaluation;
+  return typeof n?.allowSkip == "boolean" ? n.allowSkip : e.meta.allowSkip;
+}, mt = (e, t) => {
+  if (!e) return !0;
+  const n = b(e.type);
+  if (!n?.isComplete) return !0;
+  const s = n.schema.safeParse(e.data);
+  return s.success ? n.isComplete({ data: s.data, answer: t }) : !0;
+}, ht = (e) => j(Object.values(e.results)), ve = (e, t, n = /* @__PURE__ */ new Date()) => {
+  const s = {};
+  for (const d of t.history)
+    s[d] = (s[d] ?? 0) + 1;
+  const r = {};
+  for (const [d, h] of Object.entries(t.confidence ?? {}))
+    r[d] = h.level;
+  const i = {};
+  for (const d of /* @__PURE__ */ new Set([
+    ...Object.keys(t.elapsedMs),
+    t.currentNodeId
+  ]))
+    i[d] = Ie(t, d, n) / 1e3;
+  const a = Se(t, n) / 1e3, u = e.meta.timeLimit ?? null, f = {};
+  for (const d of e.nodes)
+    d.section && (f[d.id] = d.section);
+  return {
+    answers: t.answers,
+    results: t.results,
+    tries: t.tries,
+    visits: s,
+    confidence: r,
+    timeSpent: i,
+    totalTimeSpent: a,
+    timeRemaining: u === null ? null : Math.max(0, u - a),
+    history: t.history,
+    sections: f
+  };
+}, pt = (e, t) => te(e.answers, t), gt = (e, t) => te(e.results, t), te = (e, t) => {
+  if (!t) return { ...e };
+  const n = {};
+  for (const s of t)
+    s in e && (n[s] = e[s]);
+  return n;
+}, ke = (e, t, n = "optimistic", s = () => !0) => {
+  const r = /* @__PURE__ */ new Set(), i = (a) => {
+    if (Q(e, a)) return 0;
+    if (r.has(a)) return Number.POSITIVE_INFINITY;
+    r.add(a);
+    const u = k(e, a).map((f) => {
+      const d = p(e, f.target), h = i(f.target);
+      return Number.isFinite(h) ? d && !s(d) ? h : h + 1 : h;
+    }).filter(Number.isFinite);
+    return r.delete(a), u.length === 0 ? Number.POSITIVE_INFINITY : n === "optimistic" ? Math.min(...u) : Math.max(...u);
+  };
+  return p(e, t) ? i(t) : Number.POSITIVE_INFINITY;
+}, Ie = (e, t, n = /* @__PURE__ */ new Date()) => {
+  const s = e.elapsedMs[t] ?? 0;
+  return e.currentNodeId !== t || e.status !== "inProgress" ? s : s + ne(e, n);
+}, Se = (e, t = /* @__PURE__ */ new Date()) => {
+  const n = Object.values(e.elapsedMs).reduce(
+    (s, r) => s + r,
+    0
+  );
+  return e.status === "inProgress" ? n + ne(e, t) : n;
+}, ne = (e, t) => Math.max(0, t.getTime() - new Date(e.enteredAt).getTime()), wt = (e) => {
+  const n = e?.data?.evaluation?.timeLimit;
+  return typeof n == "number" && n > 0 ? n * 1e3 : null;
+}, bt = (e, t) => {
+  const n = t.history.length;
+  if (t.status !== "inProgress")
+    return { visited: n, remaining: 0, ratio: 1 };
+  const s = ke(
+    e,
+    t.currentNodeId,
+    "optimistic",
+    (i) => K(t, i)
+  ), r = Number.isFinite(s) ? n + s : n;
+  return { visited: n, remaining: s, ratio: r === 0 ? 0 : n / r };
+}, Te = (e) => {
+  const t = typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : $e();
+  return e ? `${e}-${t}` : t;
+}, $e = () => {
+  const e = new Uint8Array(16);
+  if (typeof crypto < "u" && typeof crypto.getRandomValues == "function")
+    crypto.getRandomValues(e);
+  else
+    for (let n = 0; n < e.length; n++)
+      e[n] = Math.floor(Math.random() * 256);
+  e[6] = e[6] & 15 | 64, e[8] = e[8] & 63 | 128;
+  const t = Array.from(e, (n) => n.toString(16).padStart(2, "0")).join("");
+  return `${t.slice(0, 8)}-${t.slice(8, 12)}-${t.slice(12, 16)}-${t.slice(16, 20)}-${t.slice(20)}`;
+}, Ne = 1, se = [
+  "en",
+  "de",
+  "fr",
+  "nl",
+  "es",
+  "it",
+  "pt",
+  "tr"
+], Ae = o.enum(se), P = [
+  "correct",
+  "wrong",
+  /**
+   * Not scorable: skipped, or a task whose evaluation is switched off. There is
+   * deliberately no "awaiting a teacher" state — bitflow grades in the browser
+   * and has no server, so nothing here could ever resolve one.
+   */
+  "unknown"
+], oe = o.enum(P), O = o.union([
+  /** Everything in one section — see `BitflowMeta.sections`. */
+  o.object({ kind: o.literal("section"), id: o.string().min(1) }),
+  /** A hand-picked set of steps. */
+  o.object({ kind: o.literal("nodes"), nodeIds: o.array(o.string().min(1)) }),
+  /**
+   * The most recently answered steps, newest first, counted off the attempt's
+   * own history. A step answered twice counts once — it is the same task.
+   */
+  o.object({ kind: o.literal("last"), count: o.number().int().positive() })
+]), Ee = o.union([
+  o.object({
+    kind: o.literal("answer"),
+    nodeId: o.string().min(1),
+    /** Dot path into the answer object, e.g. `"checked.0"`. */
+    path: o.string().optional()
+  }),
+  o.object({
+    kind: o.literal("result"),
+    nodeId: o.string().min(1),
+    /** Dot path into the result, e.g. `"state"`. */
+    path: o.string().optional()
+  }),
+  o.object({
+    kind: o.literal("tries"),
+    nodeId: o.string().min(1)
+  }),
+  /**
+   * How many times the learner has been *shown* a step, read off the history.
+   *
+   * Distinct from `tries`, which counts gradings: a content step is never
+   * graded, so a loop that goes round an explanation has nothing else to count.
+   * This is what gives a loop a way out — "after the third time, move on".
+   */
+  o.object({
+    kind: o.literal("visits"),
+    nodeId: o.string().min(1)
+  }),
+  /**
+   * How sure the learner said they were, `0`–`1`, when `meta.askConfidence` is
+   * on. Undefined for a step they were never asked about, which makes any
+   * comparison false rather than accidentally true.
+   *
+   * Confident and wrong is a different learner from unsure and wrong, and it is
+   * the branch worth drawing: one has a misconception, the other has a gap.
+   */
+  o.object({
+    kind: o.literal("confidence"),
+    nodeId: o.string().min(1)
+  }),
+  /**
+   * Seconds spent on one step, or on the whole attempt when `nodeId` is
+   * omitted. Time *spent*, on the same basis as the limits: the clock pauses
+   * when the learner is not there.
+   */
+  o.object({
+    kind: o.literal("timeSpent"),
+    nodeId: o.string().min(1).optional()
+  }),
+  /**
+   * Seconds left on `meta.timeLimit`. Undefined when the flow has no limit, so
+   * "less than a minute left" is simply false rather than true for everyone.
+   */
+  o.object({ kind: o.literal("timeRemaining") }),
+  /** Points earned so far, over the whole attempt or one scope. */
+  o.object({ kind: o.literal("score"), scope: O.optional() }),
+  /** Earned/possible so far, in `[0, 1]`. `0` when nothing is scorable yet. */
+  o.object({ kind: o.literal("scoreRatio"), scope: O.optional() }),
+  /**
+   * How many tasks so far ended in a given outcome — "at least three correct"
+   * being the branch a teacher reaches for most often.
+   *
+   * Counts tasks, not points: a partly-credited answer counts once, and only
+   * if it reached the state being counted. That is what "how many did they get
+   * right" means to the person writing the branch, whereas `score` is the
+   * measure to use when partial credit should carry weight.
+   */
+  o.object({
+    kind: o.literal("resultCount"),
+    state: oe.default("correct"),
+    scope: O.optional()
+  })
+]), Me = [
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "notIn",
+  "isTrue"
+], Oe = o.enum(Me), z = o.union([o.string(), o.number(), o.boolean()]), N = o.lazy(
+  () => o.union([
+    o.object({ type: o.literal("always") }),
+    o.object({
+      type: o.literal("compare"),
+      left: Ee,
+      op: Oe,
+      right: o.union([z, o.array(z)]).optional()
+    }),
+    o.object({
+      type: o.literal("and"),
+      conditions: o.array(N)
+    }),
+    o.object({
+      type: o.literal("or"),
+      conditions: o.array(N)
+    }),
+    o.object({ type: o.literal("not"), condition: N })
+  ])
+), je = o.object({ x: o.number(), y: o.number() }), Le = o.object({
+  id: o.string().min(1),
+  type: o.string().min(1),
+  position: je,
+  data: o.record(o.string(), o.unknown()).default({}),
+  /**
+   * The pool this step belongs to, if any — see `BitflowMeta.pools`.
+   *
+   * Membership lives on the node rather than the pool holding a list of ids,
+   * so deleting a step cannot leave a pool pointing at something that is gone.
+   */
+  pool: o.string().min(1).optional(),
+  /**
+   * The section this step belongs to, if any — see `BitflowMeta.sections`.
+   *
+   * Orthogonal to `pool`: a pool decides *which* steps a learner gets and in
+   * what order, a section says what a run of steps have in common — the
+   * passage they are all about, the name the progress line shows, and the
+   * scope a condition can count over.
+   */
+  section: o.string().min(1).optional()
+}), Pe = o.object({
+  id: o.string().min(1),
+  source: o.string().min(1),
+  target: o.string().min(1),
+  sourceHandle: o.string().optional(),
+  targetHandle: o.string().optional(),
+  /** Shown on the canvas; useful to label the two sides of a branch. */
+  label: o.string().optional(),
+  /** Absent means "always follow". */
+  condition: N.optional(),
+  /**
+   * What arriving over this edge clears on the step it lands on.
+   *
+   * This is what makes a remediation loop work. Without it, an edge that goes
+   * back to a question the learner got wrong lands on a step that already has
+   * a result, so the runtime shows the old answer marked wrong with no way to
+   * change it — the loop is drawable but does nothing.
+   *
+   * `"result"` clears the grading and keeps what they wrote, the same bargain
+   * Try again makes. `"answer"` clears both, which is what a task that
+   * *measures* something (a timed run, a typing speed) needs: its recorded
+   * figure has to be taken again, not edited.
+   *
+   * Absent means the step is left exactly as it was, which is right for an
+   * edge that goes back so the learner can *read* an answer again.
+   */
+  resetTarget: o.enum(["result", "answer"]).optional()
+}), _e = o.object({
+  x: o.number(),
+  y: o.number(),
+  zoom: o.number().positive()
+}), Ce = o.object({
+  /**
+   * Stable identity of the assessment. An attempt snapshot records it so a
+   * host cannot restore an attempt into a different flow.
+   */
+  id: o.string().min(1),
+  title: o.string().default(""),
+  description: o.string().optional(),
+  locale: Ae.default("en"),
+  /**
+   * Ask the learner how sure they are after each task. A whole-flow setting
+   * rather than a per-task one: being asked on some questions and not others
+   * reads as a hint about which ones are hard.
+   */
+  askConfidence: o.boolean().default(!1),
+  /** Ask the learner to explain their reasoning after each task. */
+  askReasoning: o.boolean().default(!1),
+  /**
+   * Groups of interchangeable steps, of which each learner gets a random few.
+   *
+   * The members stay ordinary nodes wired into the graph as usual; drawing
+   * only decides which of them a given attempt walks through, and the rest are
+   * stepped over as though they were not there. That keeps pools out of every
+   * bit, out of the condition language, and out of the report — which already
+   * copes with learners who saw different items, because branching does the
+   * same thing.
+   */
+  pools: o.array(
+    o.object({
+      id: o.string().min(1),
+      /** Shown to the author. Learners never see it. */
+      label: o.string().default(""),
+      /** How many members each learner gets. */
+      draw: o.number().int().positive(),
+      /**
+       * Show the drawn members in a random order rather than the order they
+       * are wired in.
+       *
+       * The draw was always recorded in the order it happened; until this
+       * existed nothing read that order back, so "the same ten questions,
+       * shuffled" — which is what most people mean by a randomised test —
+       * could not be expressed at all. A shuffled pool navigates by its drawn
+       * order instead of by its internal edges, so it must have exactly one
+       * way out; `validateFlow` says so when it does not. The way in needs no
+       * such rule — every edge into a shuffled pool lands on whichever member
+       * the draw put first.
+       */
+      shuffle: o.boolean().default(!1)
+    })
+  ).default([]),
+  /**
+   * Named runs of steps that belong together.
+   *
+   * A section carries the thing its steps share and the flow had nowhere to
+   * put: the passage, listing or diagram every question in it refers to. Before
+   * this, a reading comprehension with five questions meant pasting the passage
+   * into all five, because a content step shows its text once and is gone.
+   *
+   * It is also a scope — `ScopeSchema` — so "did they pass this section" is a
+   * branch rather than a hand-listed set of node ids, and the name shows on the
+   * progress line so a learner knows where they are in a long assessment.
+   */
+  sections: o.array(
+    o.object({
+      id: o.string().min(1),
+      /** Shown to the learner above every step in the section. */
+      label: o.string().default(""),
+      /**
+       * Markdown rendered above every step in the section — the passage, the
+       * code listing, the data table the questions are about.
+       */
+      markdown: o.string().default("")
+    })
+  ).default([]),
+  /**
+   * How freely the learner may move.
+   *
+   * - `linear` — forwards only. An exam.
+   * - `back` — they may step back through what they have seen. The default,
+   *   and what the runtime always did.
+   * - `free` — they may jump to any step they have already visited, from a
+   *   list. That list doubles as the check-your-work screen before finishing.
+   *
+   * Going back re-runs the branch on the way forward again, in every mode: an
+   * answer changed on the second pass has to be able to send them elsewhere.
+   */
+  navigation: o.enum(["linear", "back", "free"]).default("back"),
+  /**
+   * Whether a learner may pass on a task without answering. A task may
+   * override it — `EvaluationSchema.allowSkip` — for the one question everyone
+   * has to attempt.
+   */
+  allowSkip: o.boolean().default(!0),
+  /**
+   * Seconds for the whole assessment. Counted as time actually spent, not wall
+   * clock: closing the tab pauses it. That is both fairer and the only rule
+   * that survives a reload, since a snapshot records time per task rather than
+   * a deadline.
+   */
+  timeLimit: o.number().int().positive().optional()
+}), De = o.object({
+  version: o.literal(Ne),
+  meta: Ce,
+  nodes: o.array(Le),
+  edges: o.array(Pe),
+  /** Editor camera. Presentation only; never affects a learner's run. */
+  viewport: _e.optional()
+}), Fe = o.object({
+  message: o.string(),
+  severity: o.enum(["error", "warning", "info", "success"])
+}), Re = o.object({
+  mode: o.enum(["auto", "skip"]).default("auto"),
+  enableRetry: o.boolean().default(!1),
+  showFeedback: o.boolean().default(!0),
+  /**
+   * What this task is worth relative to the others. The runtime multiplies the
+   * bit's own score by it, so a bit never has to think about weighting — and a
+   * new bit gets it without doing anything.
+   */
+  weight: o.number().min(0).default(1),
+  /**
+   * Seconds the learner gets on this task, counted from when they arrive.
+   * Omitted means no limit.
+   */
+  timeLimit: o.number().int().positive().optional(),
+  /**
+   * Whether this task may be passed on. Omitted follows the flow's
+   * `meta.allowSkip`, which is the answer for all but the odd question that
+   * everyone has to attempt.
+   */
+  allowSkip: o.boolean().optional()
+}), yt = () => Re.parse({}), Be = o.object({
+  state: oe,
+  /** Omitted means "worth one point, earned iff correct". */
+  score: o.object({ earned: o.number(), possible: o.number().nonnegative() }).optional(),
+  feedback: o.array(Fe).optional(),
+  /** Whether the learner may try again, when the bit allows retries at all. */
+  allowRetry: o.boolean().optional(),
+  /** Bit-specific extras, e.g. which choices were right. */
+  detail: o.record(o.string(), o.unknown()).optional()
+}), re = 1, Ve = o.object({
+  /** `0`–`1`; how sure the learner said they were. */
+  level: o.number().min(0).max(1)
+}), We = o.enum([
+  "inProgress",
+  "completed",
+  "abandoned"
+]), Ue = o.object({
+  schemaVersion: o.literal(re),
+  flowId: o.string().min(1),
+  flowSchemaVersion: o.number().int(),
+  attemptId: o.string().min(1),
+  status: We,
+  currentNodeId: o.string().min(1),
+  /** Visited node ids, oldest first, including the current one. */
+  history: o.array(o.string().min(1)),
+  answers: o.record(o.string(), o.unknown()),
+  results: o.record(o.string(), Be),
+  tries: o.record(o.string(), o.number().int().nonnegative()),
+  elapsedMs: o.record(o.string(), o.number().nonnegative()),
+  /**
+   * Pool id → the node ids this attempt drew, in the order they were drawn.
+   *
+   * Recorded rather than re-rolled, so a reload resumes the same assessment.
+   * A pool the document has gained since is drawn on first use; one it has
+   * lost is simply never consulted again.
+   */
+  pools: o.record(o.string(), o.array(o.string())).default({}),
+  confidence: o.record(o.string(), Ve).optional(),
+  reasoning: o.record(o.string(), o.string()).optional(),
+  startedAt: o.iso.datetime(),
+  updatedAt: o.iso.datetime(),
+  /** Timestamp the current node was entered; drives `elapsedMs`. */
+  enteredAt: o.iso.datetime(),
+  completedAt: o.iso.datetime().optional()
+}), S = (e) => (e ?? /* @__PURE__ */ new Date()).toISOString(), y = (e, t, n) => ({ ...e, ...t, updatedAt: S(n) }), He = (e, t = {}) => {
+  const n = fe(e);
+  if (!n)
+    return {
+      ok: !1,
+      error: w("INVALID_FLOW", "The flow has no nodes to start at.")
+    };
+  const s = S(t.now);
+  return {
+    ok: !0,
+    value: {
+      schemaVersion: re,
+      flowId: e.meta.id,
+      flowSchemaVersion: e.version,
+      attemptId: t.attemptId ?? Te("attempt"),
+      status: "inProgress",
+      currentNodeId: n,
+      history: [n],
+      answers: {},
+      results: {},
+      tries: {},
+      elapsedMs: {},
+      // Drawn once, at the start, and carried in the snapshot from then on:
+      // re-rolling on every render would hand the learner a different
+      // assessment each time the page reloaded.
+      pools: me(e, t.random),
+      startedAt: s,
+      updatedAt: s,
+      enteredAt: s
+    }
+  };
+}, vt = (e, t) => {
+  const n = typeof t == "string" ? ze(t) : t;
+  if (n === void 0)
+    return {
+      ok: !1,
+      error: w("INVALID_ATTEMPT", "The attempt is not valid JSON.")
+    };
+  const s = Ue.safeParse(n);
+  if (!s.success)
+    return {
+      ok: !1,
+      error: w(
+        "INVALID_ATTEMPT",
+        "The attempt does not match the attempt snapshot schema.",
+        _(s.error.issues)
+      )
+    };
+  const r = s.data;
+  return r.flowId !== e.meta.id ? {
+    ok: !1,
+    error: w(
+      "FLOW_ATTEMPT_MISMATCH",
+      `The attempt belongs to flow "${r.flowId}" but the loaded flow is "${e.meta.id}".`
+    )
+  } : r.flowSchemaVersion !== e.version ? {
+    ok: !1,
+    error: w(
+      "FLOW_ATTEMPT_MISMATCH",
+      `The attempt was recorded against flow schema version ${r.flowSchemaVersion}, but the flow is version ${e.version}.`
+    )
+  } : p(e, r.currentNodeId) ? { ok: !0, value: r } : {
+    ok: !1,
+    error: w(
+      "FLOW_ATTEMPT_MISMATCH",
+      `The attempt stops at node "${r.currentNodeId}", which the flow does not contain.`
+    )
+  };
+}, ze = (e) => {
+  try {
+    return JSON.parse(e);
+  } catch {
+    return;
+  }
+}, kt = (e, t) => y(e, { status: "abandoned" }, t), It = (e, t, n, s) => y(e, { answers: { ...e.answers, [t]: n } }, s), St = (e, t, n, s) => y(
+  e,
+  { confidence: { ...e.confidence, [t]: n } },
+  s
+), Tt = (e, t, n, s) => y(
+  e,
+  { reasoning: { ...e.reasoning, [t]: n } },
+  s
+), $t = (e, t, n = {}) => {
+  if (!p(e, t))
+    return {
+      ok: !1,
+      error: w(
+        "INVALID_FLOW",
+        `The flow does not contain a node "${t}".`
+      )
+    };
+  const s = He(e, n);
+  return s.ok ? {
+    ok: !0,
+    value: { ...s.value, currentNodeId: t, history: [t] }
+  } : s;
+}, Nt = async (e, t, n, s, r) => {
+  const i = p(e, n);
+  if (!i)
+    return {
+      ok: !1,
+      error: w(
+        "INVALID_FLOW",
+        `The flow does not contain a node "${n}".`
+      )
+    };
+  const a = b(i.type);
+  if (!a)
+    return {
+      ok: !1,
+      error: w(
+        "UNKNOWN_BIT_TYPE",
+        `No bit is registered for type "${i.type}".`
+      )
+    };
+  const u = s === void 0 ? t.answers[n] : s;
+  let f;
+  if (!a.evaluate)
+    f = { state: "unknown" };
+  else {
+    const d = a.schema.safeParse(i.data);
+    if (!d.success)
+      return {
+        ok: !1,
+        error: w(
+          "INVALID_FLOW",
+          `Node "${n}" (${i.type}) is not configured correctly: ${d.error.issues.map((h) => h.message).join(" ")}`
+        )
+      };
+    try {
+      f = await a.evaluate({ data: d.data, answer: u });
+    } catch (h) {
+      return {
+        ok: !1,
+        error: w(
+          "EVALUATION_FAILED",
+          `Evaluating node "${n}" (${i.type}) failed: ${h instanceof Error ? h.message : String(h)}`
+        )
+      };
+    }
+  }
+  return {
+    ok: !0,
+    value: y(
+      t,
+      {
+        answers: { ...t.answers, [n]: u },
+        results: { ...t.results, [n]: Je(f, i) },
+        tries: { ...t.tries, [n]: (t.tries[n] ?? 0) + 1 }
+      },
+      r
+    )
+  };
+}, Je = (e, t) => {
+  const s = t.data?.evaluation?.weight;
+  if (typeof s != "number" || s === 1 || s < 0) return e;
+  const r = Y(e);
+  return {
+    ...e,
+    score: { earned: r.earned * s, possible: r.possible * s }
+  };
+}, At = (e, t, n) => y(
+  e,
+  {
+    results: { ...e.results, [t]: { state: "unknown" } },
+    tries: { ...e.tries, [t]: (e.tries[t] ?? 0) + 1 }
+  },
+  n
+), Et = (e, t, n) => {
+  const s = { ...e.results };
+  return delete s[t], y(e, { results: s }, n);
+}, A = (e, t) => {
+  const n = Math.max(
+    0,
+    (t ?? /* @__PURE__ */ new Date()).getTime() - new Date(e.enteredAt).getTime()
+  );
+  return {
+    elapsedMs: {
+      ...e.elapsedMs,
+      [e.currentNodeId]: (e.elapsedMs[e.currentNodeId] ?? 0) + n
+    }
+  };
+}, Mt = (e, t, n) => {
+  if (t.status !== "inProgress") return t;
+  const s = S(n), r = x(e, t.currentNodeId, ve(e, t, n), {
+    // Steps this attempt did not draw are walked past, not stopped on.
+    isActive: (u) => K(t, u),
+    // A shuffled pool is walked in the order this attempt drew, not as wired.
+    order: t.pools
+  });
+  if (r === null)
+    return y(
+      t,
+      {
+        ...A(t, n),
+        status: "completed",
+        completedAt: s
+      },
+      n
+    );
+  const i = r.nodeId, a = b(p(e, i)?.type ?? "")?.kind === "end";
+  return y(
+    t,
+    {
+      ...A(t, n),
+      // Clearing before arriving, not after, so the learner never sees the
+      // stale result flash on the step they were sent back to.
+      ...Ye(t, i, r.edge?.resetTarget),
+      currentNodeId: i,
+      history: [...t.history, i],
+      enteredAt: s,
+      ...a ? { status: "completed", completedAt: s } : {}
+    },
+    n
+  );
+}, Ye = (e, t, n) => {
+  if (!n) return {};
+  const s = { ...e.results };
+  if (delete s[t], n === "result") return { results: s };
+  const r = { ...e.answers };
+  return delete r[t], { results: s, answers: r };
+}, Ot = (e, t, n) => {
+  if (!qe(e, t)) return t;
+  const s = ee(t);
+  return s === null || !p(e, s) ? t : y(
+    t,
+    {
+      ...A(t, n),
+      currentNodeId: s,
+      history: t.history.slice(0, -1),
+      enteredAt: S(n),
+      status: "inProgress",
+      completedAt: void 0
+    },
+    n
+  );
+}, qe = (e, t) => {
+  if (e.meta.navigation === "linear") return !1;
+  const n = ee(t);
+  return n !== null && p(e, n) !== void 0;
+}, jt = (e, t, n, s) => {
+  if (!we(e, t, n) || n === t.currentNodeId) return t;
+  const r = t.history.indexOf(n);
+  return y(
+    t,
+    {
+      ...A(t, s),
+      currentNodeId: n,
+      history: t.history.slice(0, r + 1),
+      enteredAt: S(s),
+      status: "inProgress",
+      completedAt: void 0
+    },
+    s
+  );
+}, Lt = (e) => e.status === "completed", Pt = (e, t) => Q(e, t.currentNodeId), _t = o.object({
+  /**
+   * A `data:` URI. A plain URL still parses, because documents written before
+   * this existed have to keep working, but the editor no longer produces one
+   * and warns where it finds one.
+   */
+  src: o.string().default(""),
+  /**
+   * What the picture shows. Required wherever the picture carries meaning —
+   * each task decides that for itself, because a decorative image is a real
+   * thing too.
+   */
+  alt: o.string().default("")
+}), Ct = (e) => e.startsWith("data:"), Dt = (e) => e.length, Ft = (e) => e < 1024 ? `${e} B` : e < 1024 * 1024 ? `${Math.round(e / 1024)} kB` : `${(e / (1024 * 1024)).toFixed(1)} MB`, Rt = (e, t, n) => {
+  const s = Math.max(e, t);
+  if (s <= n || s === 0)
+    return { width: Math.round(e), height: Math.round(t) };
+  const r = n / s;
+  return {
+    width: Math.max(1, Math.round(e * r)),
+    height: Math.max(1, Math.round(t * r))
+  };
+}, Ge = "en", J = (e) => typeof e == "string" && se.includes(e), D = (e, t = Ge) => {
+  if (!e) return t;
+  if (J(e)) return e;
+  const n = e.split("-")[0]?.toLowerCase();
+  return J(n) ? n : t;
+}, Ke = (e, t) => t ? e.replace(
+  /\{(\w+)\}/g,
+  (n, s) => s in t ? String(t[s]) : n
+) : e, Qe = (e, t, n, s) => {
+  const r = D(typeof n == "string" ? n : void 0), i = e[r]?.[t] ?? e.en[t] ?? t;
+  return Ke(i, s);
+}, Bt = (e, t) => {
+  const n = D(typeof t == "string" ? t : void 0);
+  return (s, r) => Qe(e, s, n, r);
+}, Xe = (e, t, n = { dateStyle: "medium" }) => new Intl.DateTimeFormat(D(
+  typeof t == "string" ? t : void 0
+), n).format(new Date(e)), Vt = (e, t) => Xe(e, t, { dateStyle: "medium", timeStyle: "short" }), Wt = (e) => {
+  const t = Math.max(0, Math.round(e / 1e3)), n = t % 60, s = Math.floor(t / 60) % 60, r = Math.floor(t / 3600), i = (a) => String(a).padStart(2, "0");
+  return r > 0 ? `${r}:${i(s)}:${i(n)}` : `${s}:${i(n)}`;
+}, Ze = (e, t, n) => {
+  if (!t.condition) return [];
+  const s = [], r = new Set(
+    e.nodes.filter((l) => b(l.type)?.kind === "task").map((l) => l.id)
+  ), i = new Set(e.nodes.map((l) => l.id)), a = new Set(e.meta.sections.map((l) => l.id)), u = ie(e, t.source), f = u.filter((l) => r.has(l)).length, d = new Set(u), h = (l) => {
+    if (!l) return f;
+    switch (l.kind) {
+      case "nodes":
+        return l.nodeIds.filter(
+          (c) => r.has(c) && d.has(c)
+        ).length;
+      case "section":
+        return e.nodes.filter(
+          (c) => c.section === l.id && r.has(c.id) && d.has(c.id)
+        ).length;
+      case "last":
+        return Math.min(l.count, f);
+    }
+  }, T = (l) => {
+    if (l) {
+      if (l.kind === "section") {
+        a.has(l.id) ? h(l) === 0 && s.push({
+          path: n,
+          message: `Section "${l.id}" has no task before this connection, so counting it here is never anything but zero.`
+        }) : s.push({
+          path: n,
+          message: `This rule counts section "${l.id}", which the flow does not declare.`
+        });
+        return;
+      }
+      if (l.kind === "nodes") {
+        if (l.nodeIds.length === 0) {
+          s.push({
+            path: n,
+            message: "This rule counts no steps at all, so it is always zero."
+          });
+          return;
+        }
+        for (const c of l.nodeIds)
+          i.has(c) ? r.has(c) ? d.has(c) || s.push({
+            path: n,
+            message: `The learner cannot have reached "${c}" by this point in the flow, so counting it here does nothing.`
+          }) : s.push({
+            path: n,
+            message: `"${c}" is not a task, so it never contributes a result to count.`
+          }) : s.push({
+            path: n,
+            message: `This rule counts "${c}", which is not a node in this flow.`
+          });
+      }
+    }
+  }, E = (l) => {
+    switch (l.type) {
+      case "always":
+        return;
+      case "not":
+        E(l.condition);
+        return;
+      case "and":
+      case "or":
+        l.conditions.length === 0 && s.push({
+          path: n,
+          message: l.type === "and" ? "This condition has nothing in it, so it is always true. Add a rule or remove it." : "This condition has nothing in it, so it is never true. Add a rule or remove it."
+        }), l.conditions.forEach(E);
+        return;
+      case "compare":
+        ae(l);
+    }
+  }, ae = (l) => {
+    const { left: c, op: g, right: m } = l;
+    "scope" in c && T(c.scope);
+    const v = "nodeId" in c ? c.nodeId : void 0;
+    if (v !== void 0 && i.has(v) && (!(c.kind === "answer" || c.kind === "visits" || c.kind === "timeSpent") && !r.has(v) ? s.push({
+      path: n,
+      message: `"${v}" is not a task, so it never has a result to compare. Point this at a task.`
+    }) : d.has(v) || s.push({
+      path: n,
+      message: `The learner cannot have reached "${v}" by this point in the flow, so this connection is never followed.`
+    })), c.kind === "confidence" && !e.meta.askConfidence && s.push({
+      path: n,
+      message: "This flow does not ask how sure the learner is, so there is never a confidence to compare. Turn on the confidence question, or use a different rule."
+    }), c.kind === "timeRemaining" && e.meta.timeLimit === void 0 && s.push({
+      path: n,
+      message: "This flow has no time limit, so there is never any time remaining to compare. Set a limit for the whole assessment, or use time spent instead."
+    }), g === "in" || g === "notIn") {
+      Array.isArray(m) ? m.length === 0 && s.push({
+        path: n,
+        message: "The list to check against is empty, so this is never true."
+      }) : s.push({
+        path: n,
+        message: "This comparison needs a list of values to check against."
+      });
+      return;
+    }
+    if (g !== "isTrue") {
+      if (m === void 0) {
+        s.push({ path: n, message: "This comparison has nothing to compare against." });
+        return;
+      }
+      if (g === "gt" || g === "gte" || g === "lt" || g === "lte") {
+        if (typeof m != "number") {
+          s.push({
+            path: n,
+            message: `"${String(m)}" is not a number, and this comparison only works on numbers.`
+          });
+          return;
+        }
+        B(c, g, m), F(c, m), R(c, m);
+        return;
+      }
+      c.kind === "result" && c.path === "state" && typeof m == "string" && !P.includes(m) && s.push({
+        path: n,
+        message: `"${m}" is not a possible outcome. Use one of: ${P.join(", ")}.`
+      }), typeof m == "number" && (B(c, g, m), F(c, m), R(c, m));
+    }
+  }, F = (l, c) => {
+    l.kind === "confidence" && (c >= 0 && c <= 1 || s.push({
+      path: n,
+      message: `How sure the learner is runs from 0 to 1, so "${c}" is outside it. The top of the five-point scale is 1, the middle is 0.6.`
+    }));
+  }, R = (l, c) => {
+    l.kind === "scoreRatio" && (c >= 0 && c <= 1 || s.push({
+      path: n,
+      message: `The share of the marks runs from 0 to 1, so "${c}" is outside it. Half the marks is 0.5, all of them is 1.`
+    }));
+  }, B = (l, c, g) => {
+    if (l.kind !== "resultCount") return;
+    if (g < 0 || !Number.isInteger(g)) {
+      s.push({
+        path: n,
+        message: "The number of tasks has to be a whole number, zero or more."
+      });
+      return;
+    }
+    const m = h(l.scope);
+    (c === "gte" || c === "eq") && g > m && s.push({
+      path: n,
+      message: m === 0 ? "There are no tasks before this connection, so counting answers here is never true." : `Only ${m} task(s) come before this connection, so "${g}" can never be reached.`
+    }), c === "gt" && g >= m && s.push({
+      path: n,
+      message: `Only ${m} task(s) come before this connection, so more than ${g} can never be reached.`
+    });
+  };
+  return E(t.condition), s;
+}, ie = (e, t) => {
+  const n = /* @__PURE__ */ new Set([t]), s = [t];
+  for (; s.length > 0; ) {
+    const r = s.shift();
+    for (const i of C(e, r))
+      n.has(i.source) || (n.add(i.source), s.push(i.source));
+  }
+  return [...n];
+}, Ut = (e, t) => ie(e, t).filter((n) => {
+  const s = e.nodes.find((r) => r.id === n);
+  return s && b(s.type)?.kind === "task";
+}), Ht = (e) => {
+  let t = e;
+  if (typeof t == "string")
+    try {
+      t = JSON.parse(t);
+    } catch (s) {
+      return {
+        ok: !1,
+        error: w(
+          "INVALID_FLOW",
+          `The flow is not valid JSON: ${s instanceof Error ? s.message : String(s)}`
+        )
+      };
+    }
+  const n = De.safeParse(t);
+  return n.success ? { ok: !0, value: n.data } : {
+    ok: !1,
+    error: w(
+      "INVALID_FLOW",
+      "The flow does not match the .bitflow schema.",
+      _(n.error.issues)
+    )
+  };
+}, zt = (e) => {
+  const t = [], n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  return e.nodes.forEach((r, i) => {
+    n.has(r.id) && t.push({
+      path: `nodes.${i}.id`,
+      message: `Duplicate node id "${r.id}".`
+    }), n.add(r.id);
+    const a = b(r.type);
+    if (!a) {
+      nt() && t.push({
+        path: `nodes.${i}.type`,
+        message: `Unknown bit type "${r.type}".`
+      });
+      return;
+    }
+    const u = a.schema.safeParse(r.data);
+    if (!u.success)
+      for (const f of _(u.error.issues))
+        t.push({
+          path: `nodes.${i}.data${f.path ? `.${f.path}` : ""}`,
+          message: f.message
+        });
+  }), e.edges.forEach((r, i) => {
+    if (s.has(r.id) && t.push({
+      path: `edges.${i}.id`,
+      message: `Duplicate edge id "${r.id}".`
+    }), s.add(r.id), n.has(r.source) || t.push({
+      path: `edges.${i}.source`,
+      message: `Edge starts at "${r.source}", which is not a node in this flow.`
+    }), n.has(r.target) || t.push({
+      path: `edges.${i}.target`,
+      message: `Edge ends at "${r.target}", which is not a node in this flow.`
+    }), r.condition) {
+      for (const a of L(r.condition))
+        n.has(a) || t.push({
+          path: `edges.${i}.condition`,
+          message: `The condition refers to node "${a}", which is not a node in this flow.`
+        });
+      t.push(
+        ...Ze(e, r, `edges.${i}.condition`)
+      );
+    }
+  }), t.push(...tt(e)), t.push(...et(e)), t.push(...xe(e)), { valid: t.length === 0, diagnostics: t };
+}, xe = (e) => {
+  const t = [], n = /* @__PURE__ */ new Set();
+  return e.meta.sections.forEach((s, r) => {
+    n.has(s.id) && t.push({
+      path: `meta.sections.${r}.id`,
+      message: `Duplicate section "${s.id}".`
+    }), n.add(s.id), ye(e, s.id).length === 0 && t.push({
+      path: `meta.sections.${r}.id`,
+      message: `The section "${s.label || s.id}" has no steps in it, so nothing shows its text.`
+    });
+  }), e.nodes.forEach((s, r) => {
+    s.section && !n.has(s.section) && t.push({
+      path: `nodes.${r}.section`,
+      message: `This step is in section "${s.section}", which the flow does not declare.`
+    });
+    const i = b(s.type)?.kind;
+    s.section && (i === "start" || i === "end") && t.push({
+      path: `nodes.${r}.section`,
+      message: `A ${i} step cannot be part of a section.`
+    });
+  }), t;
+}, et = (e) => {
+  const t = [], n = new Set(e.meta.pools.map((r) => r.id)), s = /* @__PURE__ */ new Set();
+  return e.meta.pools.forEach((r, i) => {
+    s.has(r.id) && t.push({
+      path: `meta.pools.${i}.id`,
+      message: `Duplicate pool "${r.id}".`
+    }), s.add(r.id);
+    const a = G(e, r.id);
+    if (a.length === 0) {
+      t.push({
+        path: `meta.pools.${i}.id`,
+        message: `The pool "${r.label || r.id}" has no steps in it.`
+      });
+      return;
+    }
+    if (r.draw > a.length && t.push({
+      path: `meta.pools.${i}.draw`,
+      message: `The pool "${r.label || r.id}" draws ${r.draw} steps but only has ${a.length}. Every learner would get all of them.`
+    }), r.draw === a.length && a.length > 1 && !r.shuffle && t.push({
+      path: `meta.pools.${i}.draw`,
+      message: `The pool "${r.label || r.id}" draws all ${a.length} of its steps, so every learner gets the same ones. Turn on shuffle to vary the order instead.`
+    }), !r.shuffle) return;
+    const u = Z(e, r.id);
+    if (u.length === 0)
+      t.push({
+        path: `meta.pools.${i}.shuffle`,
+        message: `Nothing leads out of the shuffled pool "${r.label || r.id}", so a learner who finishes it has nowhere to go. Connect one of its steps to what comes next.`
+      });
+    else {
+      const f = new Set(u.map((d) => d.source));
+      f.size > 1 && t.push({
+        path: `meta.pools.${i}.shuffle`,
+        message: `${f.size} steps in the shuffled pool "${r.label || r.id}" lead out of it. Because the order changes for every learner, they would all be tried in turn rather than the one you drew. Leave the pool from a single step.`
+      });
+    }
+  }), e.nodes.forEach((r, i) => {
+    r.pool && !n.has(r.pool) && t.push({
+      path: `nodes.${i}.pool`,
+      message: `This step is in pool "${r.pool}", which the flow does not declare. It will be shown to everyone.`
+    });
+    const a = b(r.type)?.kind;
+    r.pool && (a === "start" || a === "end") && t.push({
+      path: `nodes.${i}.pool`,
+      message: `A ${a} step cannot be part of a pool.`
+    });
+  }), t;
+}, tt = (e) => {
+  const t = [];
+  if (e.nodes.length === 0)
+    return [{ path: "nodes", message: "The flow has no nodes." }];
+  const n = e.nodes.filter((i) => C(e, i.id).length === 0);
+  n.length === 0 ? t.push({
+    path: "nodes",
+    message: "Every node has an incoming edge, so the flow has no place to start."
+  }) : n.length > 1 && t.push({
+    path: "nodes",
+    message: `The flow has ${n.length} possible starting points (${n.map((i) => `"${i.id}"`).join(", ")}). Connect them so only one node starts the flow.`
+  });
+  const s = /* @__PURE__ */ new Set(), r = n.map((i) => i.id);
+  for (; r.length > 0; ) {
+    const i = r.shift();
+    if (!s.has(i)) {
+      s.add(i);
+      for (const a of k(e, i)) r.push(a.target);
+    }
+  }
+  return e.nodes.forEach((i, a) => {
+    if (!s.has(i.id)) {
+      t.push({
+        path: `nodes.${a}.id`,
+        message: `Node "${i.id}" cannot be reached from the start of the flow.`
+      });
+      return;
+    }
+    const u = b(i.type);
+    u && u.kind !== "end" && k(e, i.id).length === 0 && t.push({
+      path: `nodes.${a}.id`,
+      message: `Node "${i.id}" has no outgoing edge, so the learner has nowhere to go after it. Connect it to the next node or to an end.`
+    });
+  }), t;
+}, nt = () => de().length > 0, Jt = (e, t) => {
+  if (typeof document > "u" || document.getElementById(e)) return;
+  const n = document.createElement("style");
+  n.id = e, n.textContent = t, document.head.append(n);
+};
+export {
+  re as ATTEMPT_SCHEMA_VERSION,
+  Ue as AttemptSnapshotSchema,
+  We as AttemptStatusSchema,
+  rt as BITFLOW_ERROR_CODES,
+  it as BIT_KINDS,
+  P as BIT_RESULT_STATES,
+  Pe as BitEdgeSchema,
+  Le as BitNodeSchema,
+  Be as BitResultSchema,
+  oe as BitResultStateSchema,
+  De as BitflowDocumentSchema,
+  Ce as BitflowMetaSchema,
+  Me as COMPARE_OPS,
+  Oe as CompareOpSchema,
+  N as ConditionSchema,
+  Ve as ConfidenceSchema,
+  Ge as DEFAULT_LOCALE,
+  Re as EvaluationSchema,
+  Ne as FLOW_SCHEMA_VERSION,
+  Fe as FeedbackMessageSchema,
+  _t as ImageSchema,
+  se as LOCALES,
+  Ae as LocaleSchema,
+  je as PositionSchema,
+  O as ScopeSchema,
+  Ee as ValueRefSchema,
+  _e as ViewportSchema,
+  kt as abandonAttempt,
+  $t as attemptAt,
+  w as bitflowError,
+  qe as canGoPrevious,
+  we as canGoTo,
+  mt as canLeaveNode,
+  ft as canSkip,
+  lt as clearBits,
+  pt as collectAnswers,
+  gt as collectResults,
+  ht as computeScore,
+  ve as conditionContext,
+  L as conditionNodeIds,
+  U as conditionSectionIds,
+  He as createAttempt,
+  Te as createId,
+  Bt as createTranslator,
+  yt as defaultEvaluation,
+  ke as distanceToEnd,
+  me as drawPools,
+  $ as evaluateCondition,
+  Nt as evaluateNode,
+  bt as flowProgress,
+  Ft as formatBytes,
+  Xe as formatDate,
+  Vt as formatDateTime,
+  Wt as formatDuration,
+  b as getBit,
+  p as getNode,
+  V as getPath,
+  Mt as goNext,
+  Ot as goPrevious,
+  jt as goTo,
+  ct as hasBit,
+  C as incomingEdges,
+  Jt as injectStyles,
+  Ke as interpolate,
+  K as isActiveNode,
+  Pt as isAtEnd,
+  Lt as isComplete,
+  Ct as isEmbedded,
+  J as isLocale,
+  Q as isTerminalNode,
+  de as listBits,
+  ut as nextNodeId,
+  x as nextStep,
+  k as outgoingEdges,
+  Ht as parseFlow,
+  Z as poolExitEdges,
+  G as poolMembers,
+  ee as previousNodeId,
+  at as registerBit,
+  D as resolveLocale,
+  le as resolveValueRef,
+  vt as restoreAttempt,
+  Et as retryNode,
+  Rt as scaledSize,
+  Y as scoreOf,
+  ye as sectionMembers,
+  be as sectionOf,
+  It as setAnswer,
+  St as setConfidence,
+  Tt as setReasoning,
+  At as skipNode,
+  Dt as sourceBytes,
+  fe as startNodeId,
+  wt as taskTimeLimit,
+  Ut as tasksBefore,
+  Se as timeSpent,
+  Ie as timeSpentOn,
+  _ as toDiagnostics,
+  j as totalScore,
+  Qe as translate,
+  Ze as validateCondition,
+  zt as validateFlow,
+  dt as visitedSteps
+};