capdag 1.361.331 → 1.368.19

package/formal/index.js

@@ -1,4 +1,4 @@
-// Generated by lungo 1.78.3254 from Lean 4.34.1 for program capdagFormal. Do not edit.
+// Generated by lungo 1.82.64 from Lean 4.34.1 for program capdagFormal. Do not edit.
 import * as L from "lungo-ts";
 
 async function programModule() {
@@ -12,10 +12,599 @@ async function programModule() {
   return response.arrayBuffer();
 }
 
+/** Describes CapDAG.Bifaci.Credit.Gate for polymorphic functions. */
+export function gateType() {
+  return new L.Type(
+    L.inductiveExpr(0),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Gate");
+      w.u32(0);
+      L.NAT.encode(w, v.available);
+      L.option(L.STRING).encode(w, v.closed);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Gate`);
+      return ({ available: L.NAT.decode(r), closed: L.option(L.STRING).decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Credit.Acquire for polymorphic functions. */
+export function acquireType() {
+  return new L.Type(
+    L.inductiveExpr(1),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Acquire");
+      switch (v.kind) {
+        case "acquired":
+          w.u32(0);
+          gateType().encode(w, v.gate);
+          return;
+        case "wait":
+          w.u32(1);
+          return;
+        case "closed":
+          w.u32(2);
+          L.STRING.encode(w, v.reason);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Credit.Acquire`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "acquired", gate: gateType().decode(r) });
+        case 1: return ({ kind: "wait" });
+        case 2: return ({ kind: "closed", reason: L.STRING.decode(r) });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Acquire`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Credit.Window for polymorphic functions. */
+export function windowType() {
+  return new L.Type(
+    L.inductiveExpr(2),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Window");
+      w.u32(0);
+      L.NAT.encode(w, v.remaining);
+      L.NAT.encode(w, v.pending);
+      L.NAT.encode(w, v.batch);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Window`);
+      return ({ remaining: L.NAT.decode(r), pending: L.NAT.decode(r), batch: L.NAT.decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Credit.Arrival for polymorphic functions. */
+export function creditArrivalType() {
+  return new L.Type(
+    L.inductiveExpr(3),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Arrival");
+      switch (v.kind) {
+        case "accepted":
+          w.u32(0);
+          windowType().encode(w, v.window);
+          return;
+        case "violation":
+          w.u32(1);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Credit.Arrival`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "accepted", window: windowType().decode(r) });
+        case 1: return ({ kind: "violation" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Arrival`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Credit.Granted for polymorphic functions. */
+export function grantedType() {
+  return new L.Type(
+    L.inductiveExpr(4),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Granted");
+      w.u32(0);
+      windowType().encode(w, v.window);
+      L.NAT.encode(w, v.grant);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Granted`);
+      return ({ window: windowType().decode(r), grant: L.NAT.decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Flow.FrameType for polymorphic functions. */
+export function frameTypeType() {
+  return new L.Type(
+    L.inductiveExpr(5),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Flow.FrameType");
+      switch (v.kind) {
+        case "hello":
+          w.u32(0);
+          return;
+        case "req":
+          w.u32(1);
+          return;
+        case "chunk":
+          w.u32(2);
+          return;
+        case "fin":
+          w.u32(3);
+          return;
+        case "log":
+          w.u32(4);
+          return;
+        case "err":
+          w.u32(5);
+          return;
+        case "heartbeat":
+          w.u32(6);
+          return;
+        case "streamStart":
+          w.u32(7);
+          return;
+        case "streamEnd":
+          w.u32(8);
+          return;
+        case "relayNotify":
+          w.u32(9);
+          return;
+        case "relayState":
+          w.u32(10);
+          return;
+        case "cancel":
+          w.u32(11);
+          return;
+        case "credit":
+          w.u32(12);
+          return;
+        case "closeStream":
+          w.u32(13);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Flow.FrameType`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "hello" });
+        case 1: return ({ kind: "req" });
+        case 2: return ({ kind: "chunk" });
+        case 3: return ({ kind: "fin" });
+        case 4: return ({ kind: "log" });
+        case 5: return ({ kind: "err" });
+        case 6: return ({ kind: "heartbeat" });
+        case 7: return ({ kind: "streamStart" });
+        case 8: return ({ kind: "streamEnd" });
+        case 9: return ({ kind: "relayNotify" });
+        case 10: return ({ kind: "relayState" });
+        case 11: return ({ kind: "cancel" });
+        case 12: return ({ kind: "credit" });
+        case 13: return ({ kind: "closeStream" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Flow.FrameType`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Flow.Reorder for polymorphic functions. */
+export function reorderType() {
+  return new L.Type(
+    L.inductiveExpr(6),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Flow.Reorder");
+      w.u32(0);
+      L.NAT.encode(w, v.expected);
+      L.list(L.NAT).encode(w, v.held);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Flow.Reorder`);
+      return ({ expected: L.NAT.decode(r), held: L.list(L.NAT).decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Flow.Accepted for polymorphic functions. */
+export function acceptedType() {
+  return new L.Type(
+    L.inductiveExpr(7),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Flow.Accepted");
+      switch (v.kind) {
+        case "deliver":
+          w.u32(0);
+          reorderType().encode(w, v.flow);
+          L.list(L.NAT).encode(w, v.seqs);
+          return;
+        case "hold":
+          w.u32(1);
+          reorderType().encode(w, v.flow);
+          return;
+        case "stale":
+          w.u32(2);
+          return;
+        case "duplicate":
+          w.u32(3);
+          return;
+        case "overflow":
+          w.u32(4);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Flow.Accepted`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "deliver", flow: reorderType().decode(r), seqs: L.list(L.NAT).decode(r) });
+        case 1: return ({ kind: "hold", flow: reorderType().decode(r) });
+        case 2: return ({ kind: "stale" });
+        case 3: return ({ kind: "duplicate" });
+        case 4: return ({ kind: "overflow" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Flow.Accepted`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Pools.State for polymorphic functions. */
+export function stateType() {
+  return new L.Type(
+    L.inductiveExpr(8),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.State");
+      w.u32(0);
+      L.list(poolType()).encode(w, v.pools);
+      L.list(waiterType()).encode(w, v.queue);
+      L.NAT.encode(w, v.next);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.State`);
+      return ({ pools: L.list(poolType()).decode(r), queue: L.list(waiterType()).decode(r), next: L.NAT.decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Pools.Waiter for polymorphic functions. */
+export function waiterType() {
+  return new L.Type(
+    L.inductiveExpr(9),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.Waiter");
+      w.u32(0);
+      L.NAT.encode(w, v.ticket);
+      L.list(L.STRING).encode(w, v.chain);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.Waiter`);
+      return ({ ticket: L.NAT.decode(r), chain: L.list(L.STRING).decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Pools.Arrival for polymorphic functions. */
+export function poolsArrivalType() {
+  return new L.Type(
+    L.inductiveExpr(10),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.Arrival");
+      switch (v.kind) {
+        case "admitted":
+          w.u32(0);
+          stateType().encode(w, v.state);
+          return;
+        case "queued":
+          w.u32(1);
+          stateType().encode(w, v.state);
+          L.NAT.encode(w, v.ticket);
+          L.NAT.encode(w, v.position);
+          return;
+        case "unknownPool":
+          w.u32(2);
+          L.STRING.encode(w, v.name);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Pools.Arrival`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "admitted", state: stateType().decode(r) });
+        case 1: return ({ kind: "queued", state: stateType().decode(r), ticket: L.NAT.decode(r), position: L.NAT.decode(r) });
+        case 2: return ({ kind: "unknownPool", name: L.STRING.decode(r) });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.Arrival`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Pools.Patience for polymorphic functions. */
+export function patienceType() {
+  return new L.Type(
+    L.inductiveExpr(11),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.Patience");
+      switch (v.kind) {
+        case "unbounded":
+          w.u32(0);
+          return;
+        case "atMost":
+          w.u32(1);
+          L.NAT.encode(w, v.remaining);
+          return;
+        case "exhausted":
+          w.u32(2);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Pools.Patience`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "unbounded" });
+        case 1: return ({ kind: "atMost", remaining: L.NAT.decode(r) });
+        case 2: return ({ kind: "exhausted" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.Patience`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Phase for polymorphic functions. */
+export function phaseType() {
+  return new L.Type(
+    L.inductiveExpr(12),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Phase");
+      switch (v.kind) {
+        case "created":
+          w.u32(0);
+          return;
+        case "streaming":
+          w.u32(1);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Phase`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "created" });
+        case 1: return ({ kind: "streaming" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Phase`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Emitted for polymorphic functions. */
+export function emittedType() {
+  return new L.Type(
+    L.inductiveExpr(13),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Emitted");
+      switch (v.kind) {
+        case "streamStart":
+          w.u32(0);
+          L.STRING.encode(w, v.stream);
+          return;
+        case "chunk":
+          w.u32(1);
+          L.STRING.encode(w, v.stream);
+          L.NAT.encode(w, v.index);
+          return;
+        case "streamEnd":
+          w.u32(2);
+          L.STRING.encode(w, v.stream);
+          L.option(L.NAT).encode(w, v.count);
+          return;
+        case "fin":
+          w.u32(3);
+          return;
+        case "err":
+          w.u32(4);
+          return;
+        case "other":
+          w.u32(5);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Emitted`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "streamStart", stream: L.STRING.decode(r) });
+        case 1: return ({ kind: "chunk", stream: L.STRING.decode(r), index: L.NAT.decode(r) });
+        case 2: return ({ kind: "streamEnd", stream: L.STRING.decode(r), count: L.option(L.NAT).decode(r) });
+        case 3: return ({ kind: "fin" });
+        case 4: return ({ kind: "err" });
+        case 5: return ({ kind: "other" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Emitted`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Violation for polymorphic functions. */
+export function violationType() {
+  return new L.Type(
+    L.inductiveExpr(14),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Violation");
+      switch (v.kind) {
+        case "afterEnd":
+          w.u32(0);
+          return;
+        case "streamRestarted":
+          w.u32(1);
+          L.STRING.encode(w, v.stream);
+          return;
+        case "streamNotOpen":
+          w.u32(2);
+          L.STRING.encode(w, v.stream);
+          return;
+        case "chunkOutOfPlace":
+          w.u32(3);
+          L.STRING.encode(w, v.stream);
+          L.NAT.encode(w, v.expected);
+          L.NAT.encode(w, v.got);
+          return;
+        case "chunkCountWrong":
+          w.u32(4);
+          L.STRING.encode(w, v.stream);
+          L.NAT.encode(w, v.sent);
+          L.NAT.encode(w, v.said);
+          return;
+        case "endWithOpenStream":
+          w.u32(5);
+          L.STRING.encode(w, v.stream);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Violation`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "afterEnd" });
+        case 1: return ({ kind: "streamRestarted", stream: L.STRING.decode(r) });
+        case 2: return ({ kind: "streamNotOpen", stream: L.STRING.decode(r) });
+        case 3: return ({ kind: "chunkOutOfPlace", stream: L.STRING.decode(r), expected: L.NAT.decode(r), got: L.NAT.decode(r) });
+        case 4: return ({ kind: "chunkCountWrong", stream: L.STRING.decode(r), sent: L.NAT.decode(r), said: L.NAT.decode(r) });
+        case 5: return ({ kind: "endWithOpenStream", stream: L.STRING.decode(r) });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Violation`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Disposition for polymorphic functions. */
+export function dispositionType() {
+  return new L.Type(
+    L.inductiveExpr(15),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Disposition");
+      switch (v.kind) {
+        case "route":
+          w.u32(0);
+          return;
+        case "straggler":
+          w.u32(1);
+          return;
+        case "noRoute":
+          w.u32(2);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Disposition`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "route" });
+        case 1: return ({ kind: "straggler" });
+        case 2: return ({ kind: "noRoute" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Disposition`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Terminal for polymorphic functions. */
+export function terminalType() {
+  return new L.Type(
+    L.inductiveExpr(16),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Terminal");
+      switch (v.kind) {
+        case "finished":
+          w.u32(0);
+          return;
+        case "failed":
+          w.u32(1);
+          return;
+        case "cancelled":
+          w.u32(2);
+          return;
+        case "masterDied":
+          w.u32(3);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Terminal`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "finished" });
+        case 1: return ({ kind: "failed" });
+        case 2: return ({ kind: "cancelled" });
+        case 3: return ({ kind: "masterDied" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Terminal`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Write for polymorphic functions. */
+export function writeType() {
+  return new L.Type(
+    L.inductiveExpr(17),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Write");
+      switch (v.kind) {
+        case "send":
+          w.u32(0);
+          L.BOOL.encode(w, v.ends);
+          return;
+        case "suppress":
+          w.u32(1);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Write`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "send", ends: L.BOOL.decode(r) });
+        case 1: return ({ kind: "suppress" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Write`);
+      }
+    },
+  );
+}
+
 /** Describes CapDAG.Exec.WfCap for polymorphic functions. */
 export function wfCapType() {
   return new L.Type(
-    L.inductiveExpr(0),
+    L.inductiveExpr(18),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Exec.WfCap");
       w.u32(0);
@@ -35,7 +624,7 @@ export function wfCapType() {
 /** Describes CapDAG.Effect for polymorphic functions. */
 export function effectType() {
   return new L.Type(
-    L.inductiveExpr(1),
+    L.inductiveExpr(19),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Effect");
       switch (v.kind) {
@@ -68,10 +657,81 @@ export function effectType() {
   );
 }
 
+/** Describes CapDAG.Exec.WfQuery for polymorphic functions. */
+export function wfQueryType() {
+  return new L.Type(
+    L.inductiveExpr(20),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Exec.WfQuery");
+      w.u32(0);
+      wfAskType().encode(w, v.input);
+      wfAskType().encode(w, v.output);
+      wfType().encode(w, v.tags);
+      effectType().encode(w, v.effect);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Exec.WfQuery`);
+      return ({ input: wfAskType().decode(r), output: wfAskType().decode(r), tags: wfType().decode(r), effect: effectType().decode(r) });
+    },
+  );
+}
+
+/** Lean's TaggedUrn.Exec.Wf, held by handle: only the program's functions make and read its values. */
+export class Wf extends L.Opaque {}
+
+/** Describes TaggedUrn.Exec.Wf for polymorphic functions. */
+export function wfType() {
+  return new L.Type(
+    L.inductiveExpr(21),
+    (w, v) => {
+      if (!(v instanceof Wf)) throw new L.MalformedError("not a TaggedUrn.Exec.Wf");
+      L.OPAQUE.encode(w, v);
+    },
+    (r) => new Wf(r.program, r.u64()),
+  );
+}
+
+/** Describes CapDAG.Grade for polymorphic functions. */
+export function gradeType() {
+  return new L.Type(
+    L.inductiveExpr(22),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Grade");
+      switch (v.kind) {
+        case "exact":
+          w.u32(0);
+          return;
+        case "guaranteed":
+          w.u32(1);
+          return;
+        case "possible":
+          w.u32(2);
+          return;
+        case "none":
+          w.u32(3);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Grade`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "exact" });
+        case 1: return ({ kind: "guaranteed" });
+        case 2: return ({ kind: "possible" });
+        case 3: return ({ kind: "none" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Grade`);
+      }
+    },
+  );
+}
+
 /** Describes TaggedUrn.Constraint for polymorphic functions. */
 export function constraintType() {
   return new L.Type(
-    L.inductiveExpr(2),
+    L.inductiveExpr(23),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a TaggedUrn.Constraint");
       switch (v.kind) {
@@ -119,27 +779,92 @@ export function constraintType() {
   );
 }
 
-/** Lean's TaggedUrn.Exec.Wf, held by handle: only the program's functions make and read its values. */
-export class Wf extends L.Opaque {}
+/** Describes CapDAG.Bifaci.Pools.Pool for polymorphic functions. */
+export function poolType() {
+  return new L.Type(
+    L.inductiveExpr(24),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.Pool");
+      w.u32(0);
+      L.STRING.encode(w, v.name);
+      L.NAT.encode(w, v.capacity);
+      L.NAT.encode(w, v.active);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.Pool`);
+      return ({ name: L.STRING.decode(r), capacity: L.NAT.decode(r), active: L.NAT.decode(r) });
+    },
+  );
+}
 
-/** Describes TaggedUrn.Exec.Wf for polymorphic functions. */
-export function wfType() {
+/** Describes CapDAG.Exec.WfAsk for polymorphic functions. */
+export function wfAskType() {
   return new L.Type(
-    L.inductiveExpr(3),
+    L.inductiveExpr(25),
     (w, v) => {
-      if (!(v instanceof Wf)) throw new L.MalformedError("not a TaggedUrn.Exec.Wf");
-      L.OPAQUE.encode(w, v);
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Exec.WfAsk");
+      switch (v.kind) {
+        case "unknown":
+          w.u32(0);
+          return;
+        case "within":
+          w.u32(1);
+          wfType().encode(w, v.u);
+          return;
+        case "covers":
+          w.u32(2);
+          wfType().encode(w, v.u);
+          return;
+        case "same":
+          w.u32(3);
+          wfType().encode(w, v.u);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Exec.WfAsk`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "unknown" });
+        case 1: return ({ kind: "within", u: wfType().decode(r) });
+        case 2: return ({ kind: "covers", u: wfType().decode(r) });
+        case 3: return ({ kind: "same", u: wfType().decode(r) });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Exec.WfAsk`);
+      }
     },
-    (r) => new Wf(r.program, r.u64()),
   );
 }
 
 /** The layout fingerprint and descriptor of each type, by Lean name, for modules using them. */
 export const leanTypes = Object.freeze({
+  "CapDAG.Bifaci.Credit.Gate": Object.freeze({ fingerprint: "b10dc9a4cff1977f4f6a2c415147f497f98740255d0158fb2b3a2a99d4d1b135", type: gateType }),
+  "CapDAG.Bifaci.Credit.Acquire": Object.freeze({ fingerprint: "0dabbf62c4dad8c3f81811acc80f5c789d25191897bb2621de51b5f94e54a4c9", type: acquireType }),
+  "CapDAG.Bifaci.Credit.Window": Object.freeze({ fingerprint: "28df89763b22214ef57dfd7f1a3c0da786ff78af9768fe453cd451870749b6fe", type: windowType }),
+  "CapDAG.Bifaci.Credit.Arrival": Object.freeze({ fingerprint: "940f01cf50eb8b763b9f44cc84753fcdbc65fbc0f816ab279408e74208649797", type: creditArrivalType }),
+  "CapDAG.Bifaci.Credit.Granted": Object.freeze({ fingerprint: "47f8d3e63e9aaf7c4b602f781afce57fc832e3d4d645c6adabd25c461abed233", type: grantedType }),
+  "CapDAG.Bifaci.Flow.FrameType": Object.freeze({ fingerprint: "3d6742b864aeb68cf6add586acfcd1a9663a3816d718f8d8aadc3c5e3dab3e2f", type: frameTypeType }),
+  "CapDAG.Bifaci.Flow.Reorder": Object.freeze({ fingerprint: "d1e8b655f24db5e8b2348d6d41084a5c454346eb0a81fcf11b671432e72291bf", type: reorderType }),
+  "CapDAG.Bifaci.Flow.Accepted": Object.freeze({ fingerprint: "a821d7a044f52a71dfd932fff60d2f3560ce5197658283853a56fb54aa96b69b", type: acceptedType }),
+  "CapDAG.Bifaci.Pools.State": Object.freeze({ fingerprint: "20f7299c188d09234cda39e9cc356242e2b5bc56a09cf819d12d7f50fa24989b", type: stateType }),
+  "CapDAG.Bifaci.Pools.Waiter": Object.freeze({ fingerprint: "48d81c7e41df114e88751bb5c1f4a84c16bac3ad28d8eacba141d45f92c79da0", type: waiterType }),
+  "CapDAG.Bifaci.Pools.Arrival": Object.freeze({ fingerprint: "6bee196c56c330c4ef348f4dd5a68558b2d19105592969cc64a0e7150bd22451", type: poolsArrivalType }),
+  "CapDAG.Bifaci.Pools.Patience": Object.freeze({ fingerprint: "d32e3427e590ca6002e38cface52d020c7df74603f952bf568401f7291d5648c", type: patienceType }),
+  "CapDAG.Bifaci.Request.Phase": Object.freeze({ fingerprint: "7407437b58ce033618bf82341b13aaa9661d29a5a9b0f1bf1547ea0bfcfd8374", type: phaseType }),
+  "CapDAG.Bifaci.Request.Emitted": Object.freeze({ fingerprint: "97a274be14c5baecf9c50243d3651da838c5de4375366d4102cbcff85fb211c8", type: emittedType }),
+  "CapDAG.Bifaci.Request.Violation": Object.freeze({ fingerprint: "203fb2fc4f8ff3c79b70871b4274852e742adf97c3cc4e6631439ec66d838f09", type: violationType }),
+  "CapDAG.Bifaci.Request.Disposition": Object.freeze({ fingerprint: "540307dfb6e509ccde4b894c69566edd1f3f9c3223b9325e97ee91b20d0fb82f", type: dispositionType }),
+  "CapDAG.Bifaci.Request.Terminal": Object.freeze({ fingerprint: "3597c3196cef5e4468b5449eb0da09af414bb8c3aa40d92b027089f6ae81c870", type: terminalType }),
+  "CapDAG.Bifaci.Request.Write": Object.freeze({ fingerprint: "9ae21282903c8131c25ca1cc527e51fd1fa5137aa77c9ef4f3d091e9415a109a", type: writeType }),
   "CapDAG.Exec.WfCap": Object.freeze({ fingerprint: "2b8d6466d218f4ae6bc98d95bba55d98f21cac4a49446ae170993773cefdb830", type: wfCapType }),
   "CapDAG.Effect": Object.freeze({ fingerprint: "38c7bd3c0527cda156713cd441c9b6b92bd5df8a39108fa101449a789abcb477", type: effectType }),
-  "TaggedUrn.Constraint": Object.freeze({ fingerprint: "481fc09e23c6415a7c3f05887577ec940a6ecc84b005e63476c1060b59edcac7", type: constraintType }),
+  "CapDAG.Exec.WfQuery": Object.freeze({ fingerprint: "e734861d70e3177f6563c4492990bb65131f0450b8dfc62071eb61b6c5f08b8e", type: wfQueryType }),
   "TaggedUrn.Exec.Wf": Object.freeze({ fingerprint: "20e9f81ad195b2f4a481e7a5dcae2b3d0de6efe7b3dc720db0e2aa3b52527785", type: wfType }),
+  "CapDAG.Grade": Object.freeze({ fingerprint: "0a2a20a14d9ecca6121343df2d8a7f2478b3e837710ed522ed385d35efdf46f2", type: gradeType }),
+  "TaggedUrn.Constraint": Object.freeze({ fingerprint: "481fc09e23c6415a7c3f05887577ec940a6ecc84b005e63476c1060b59edcac7", type: constraintType }),
+  "CapDAG.Bifaci.Pools.Pool": Object.freeze({ fingerprint: "60bca9d670886c7830c76779ad692b4fbb6e4e30c0ce6b3e9d5a91a9b5b7b1e6", type: poolType }),
+  "CapDAG.Exec.WfAsk": Object.freeze({ fingerprint: "d286477c7abc4e6bc6ee2d06889372b71a5bb06605b592ebabb6ad3eaf71b952", type: wfAskType }),
 });
 
 /** The Lean program capdagFormal. */
@@ -148,8 +873,122 @@ export class CapdagFormal {
   constructor(program) {
     this.#program = program;
   }
-  accepts(pattern, request) {
-    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_daccepts", [], [[wfCapType(), pattern], [wfCapType(), request]], L.value(L.BOOL));
+  acquire(g, n) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dGate_dacquire", [], [[gateType(), g], [L.NAT, n]], L.value(acquireType()));
+  }
+  close(g, reason) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dGate_dclose", [], [[gateType(), g], [L.STRING, reason]], L.value(gateType()));
+  }
+  grant(g, n) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dGate_dgrant", [], [[gateType(), g], [L.NAT, n]], L.value(gateType()));
+  }
+  gateOpened(window) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dGate_dopened", [], [[L.NAT, window]], L.value(gateType()));
+  }
+  windowArrive(w_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_darrive", [], [[windowType(), w_]], L.value(creditArrivalType()));
+  }
+  consume(w_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_dconsume", [], [[windowType(), w_]], L.value(grantedType()));
+  }
+  continued(w_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_dcontinued", [], [[windowType(), w_]], L.value(grantedType()));
+  }
+  flush(w_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_dflush", [], [[windowType(), w_]], L.value(grantedType()));
+  }
+  windowOpened(window) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_dopened", [], [[L.NAT, window]], L.value(windowType()));
+  }
+  grantTarget(streams, named) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dgrantTarget", [], [[L.list(L.option(L.STRING)), streams], [L.option(L.STRING), named]], L.value(L.option(L.option(L.STRING))));
+  }
+  negotiate(ours, theirs) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dnegotiate", [], [[L.NAT, ours], [L.NAT, theirs]], L.value(L.option(L.NAT)));
+  }
+  code(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dFrameType_dcode", [], [[frameTypeType(), a]], L.value(L.NAT));
+  }
+  isFlow(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dFrameType_disFlow", [], [[frameTypeType(), a]], L.value(L.BOOL));
+  }
+  isTerminal(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dFrameType_disTerminal", [], [[frameTypeType(), a]], L.value(L.BOOL));
+  }
+  ofCode(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dFrameType_dofCode", [], [[L.NAT, a]], L.value(L.option(frameTypeType())));
+  }
+  accept(r_, seq, limit) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dReorder_daccept", [], [[reorderType(), r_], [L.NAT, seq], [L.NAT, limit]], L.value(acceptedType()));
+  }
+  start() {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dReorder_dstart", [], [], L.value(reorderType()));
+  }
+  admit(s, ticket) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dadmit", [], [[stateType(), s], [L.NAT, ticket]], L.value(L.option(stateType())));
+  }
+  admitNext(s) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dadmitNext", [], [[stateType(), s]], L.value(L.option(L.pair(waiterType(), stateType()))));
+  }
+  stateArrive(s, chain) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_darrive", [], [[stateType(), s], [L.list(L.STRING), chain]], L.value(poolsArrivalType()));
+  }
+  empty() {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dempty", [], [], L.value(stateType()));
+  }
+  hasRoom(s, chain) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dhasRoom", [], [[stateType(), s], [L.list(L.STRING), chain]], L.value(L.BOOL));
+  }
+  heldBack(s, name) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dheldBack", [], [[stateType(), s], [L.STRING, name]], L.value(L.NAT));
+  }
+  join(s, chain) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_djoin", [], [[stateType(), s], [L.list(L.STRING), chain]], L.value(poolsArrivalType()));
+  }
+  leave(s, ticket) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dleave", [], [[stateType(), s], [L.NAT, ticket]], L.value(stateType()));
+  }
+  position(s, ticket) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dposition", [], [[stateType(), s], [L.NAT, ticket]], L.value(L.NAT));
+  }
+  release(s, chain) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_drelease", [], [[stateType(), s], [L.list(L.STRING), chain]], L.value(stateType()));
+  }
+  setCapacity(s, name, capacity) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dsetCapacity", [], [[stateType(), s], [L.STRING, name], [L.NAT, capacity]], L.value(stateType()));
+  }
+  advertised(running, pool, configured, available) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dadvertised", [], [[L.BOOL, running], [L.STRING, pool], [L.NAT, configured], [L.option(L.NAT), available]], L.value(L.NAT));
+  }
+  chain(cap, shared) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dchain", [], [[L.STRING, cap], [L.list(L.pair(L.STRING, L.list(L.STRING))), shared]], L.value(L.list(L.STRING)));
+  }
+  effective(configured, available) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_deffective", [], [[L.NAT, configured], [L.option(L.NAT), available]], L.value(L.NAT));
+  }
+  patience(unavailableFor, grace) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dpatience", [], [[L.option(L.NAT), unavailableFor], [L.NAT, grace]], L.value(patienceType()));
+  }
+  after(p, frame) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dPhase_dafter", [], [[phaseType(), p], [frameTypeType(), frame]], L.value(phaseType()));
+  }
+  check(frames) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dcheck", [], [[L.list(emittedType()), frames]], L.value(L.option(violationType())));
+  }
+  dispose(live, endedLately) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_ddispose", [], [[L.BOOL, live], [L.BOOL, endedLately]], L.value(dispositionType()));
+  }
+  ledger(remaining, frame, granted) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dledger", [], [[L.INT, remaining], [frameTypeType(), frame], [L.NAT, granted]], L.value(L.INT));
+  }
+  terminalOf(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dterminalOf", [], [[frameTypeType(), a]], L.value(L.option(terminalType())));
+  }
+  write(over, frame) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dwrite", [], [[L.BOOL, over], [frameTypeType(), frame]], L.value(writeType()));
+  }
+  accepts(pattern, cap) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_daccepts", [], [[wfCapType(), pattern], [wfCapType(), cap]], L.value(L.BOOL));
   }
   comparable(a, b) {
     return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dcomparable", [], [[wfCapType(), a], [wfCapType(), b]], L.value(L.BOOL));
@@ -163,6 +1002,39 @@ export class CapdagFormal {
   equivalent(a, b) {
     return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dequivalent", [], [[wfCapType(), a], [wfCapType(), b]], L.value(L.BOOL));
   }
+  flows(a, b) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dflows", [], [[wfCapType(), a], [wfCapType(), b]], L.value(L.BOOL));
+  }
+  mayDispatch(candidate, request) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dmayDispatch", [], [[wfCapType(), candidate], [wfCapType(), request]], L.value(L.BOOL));
+  }
+  mayFlow(a, b) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dmayFlow", [], [[wfCapType(), a], [wfCapType(), b]], L.value(L.BOOL));
+  }
+  queryAdmits(q, c) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryAdmits", [], [[wfQueryType(), q], [wfCapType(), c]], L.value(L.BOOL));
+  }
+  queryBetween(input, output, tags) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryBetween", [], [[wfType(), input], [wfType(), output], [wfType(), tags]], L.value(wfQueryType()));
+  }
+  queryConsuming(input, tags) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryConsuming", [], [[wfType(), input], [wfType(), tags]], L.value(wfQueryType()));
+  }
+  queryGrade(q, c) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryGrade", [], [[wfQueryType(), q], [wfCapType(), c]], L.value(gradeType()));
+  }
+  queryMayAdmit(q, c) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryMayAdmit", [], [[wfQueryType(), q], [wfCapType(), c]], L.value(L.BOOL));
+  }
+  queryOfPattern(p) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryOfPattern", [], [[wfCapType(), p]], L.value(wfQueryType()));
+  }
+  queryOfRequest(r_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryOfRequest", [], [[wfCapType(), r_]], L.value(wfQueryType()));
+  }
+  queryProducing(output, tags) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryProducing", [], [[wfType(), output], [wfType(), tags]], L.value(wfQueryType()));
+  }
   rankingKey(candidate, request) {
     return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_drankingKey", [], [[wfCapType(), candidate], [wfCapType(), request]], L.value(L.pair(L.NAT, L.NAT)));
   }